javaextensions/pim/javasrc.s60/com/nokia/mj/impl/pim/utils/NativeError.java
changeset 21 2a9601315dfc
child 67 63b81d807542
equal deleted inserted replaced
18:e8e63152f320 21:2a9601315dfc
       
     1 /*
       
     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Native error codes.
       
    15  *
       
    16 */
       
    17 
       
    18 
       
    19 // PACKAGE
       
    20 package com.nokia.mj.impl.pim.utils;
       
    21 
       
    22 // IMPORTS
       
    23 import javax.microedition.pim.FieldEmptyException;
       
    24 import javax.microedition.pim.FieldFullException;
       
    25 import javax.microedition.pim.PIMException;
       
    26 import javax.microedition.pim.UnsupportedFieldException;
       
    27 import com.nokia.mj.impl.pim.ErrorString;
       
    28 import com.nokia.mj.impl.pim.GenericException;
       
    29 import com.nokia.mj.impl.utils.OsErrorMessage;
       
    30 
       
    31 // CLASS DEFINITION
       
    32 /**
       
    33  * Native side error codes and common error handling operations. In general, the
       
    34  * native side error codes are interpreted to Java exceptions in failing native
       
    35  * side invocations. There are groups of functionality that share common
       
    36  * interpretation for a set of error codes; for these a common error handling
       
    37  * operation is provided.
       
    38  *
       
    39  * The class must be public so that in can be accessed from the
       
    40  * javax.microedition.pim package (classes PIM and RepeatRule).
       
    41  */
       
    42 public final class NativeError
       
    43 {
       
    44 
       
    45     // @{
       
    46     /**
       
    47      * Checks given native-originating error code for field handling operations
       
    48      * and in error throws a suitable exception for that error.
       
    49      *
       
    50      * The field handling operations are present mainly in PIMItemImpl and
       
    51      * PIMListImpl classes (data accessors, support checkers, label getters).
       
    52      *
       
    53      * The native error codes and corresponding exceptions are listed below.
       
    54      *
       
    55      * @param aNativeErrorCode
       
    56      *            The native error code to check. For error codes other than
       
    57      *            OsErrorMessage.SUCCESS an exception is thrown.
       
    58      *
       
    59      * @param aField
       
    60      *            The field to mention in the exception description where
       
    61      *            applicable.
       
    62      *
       
    63      * @param aIndex
       
    64      *            The index to mention in the exception description where
       
    65      *            applicable.
       
    66      *
       
    67      * @exception IllegalArgumentException
       
    68      *                for OsErrorMessage.KERR_ARGUMENT (invalid field) and
       
    69      *                OsErrorMessage.KERR_TOO_BIG (invalid value).
       
    70      *
       
    71      * @exception IndexOutOfBoundsException
       
    72      *                for OsErrorMessage.KERR_NOT_FOUND.
       
    73      *
       
    74      * @exception UnsupportedFieldException
       
    75      *                for OsErrorMessage.KERR_NOT_SUPPORTED.
       
    76      *
       
    77      * @exception Generic Exception with code
       
    78      *                for any other error.
       
    79      */
       
    80     public static void handleFieldHandlingError(int aNativeErrorCode, int aField,
       
    81             int aIndex)
       
    82     {
       
    83         if (aNativeErrorCode == OsErrorMessage.SUCCESS)
       
    84         {
       
    85             return; // OK
       
    86         }
       
    87 
       
    88         switch (aNativeErrorCode)
       
    89         {
       
    90         case OsErrorMessage.KERR_ARGUMENT:
       
    91         {
       
    92             throw new IllegalArgumentException(ErrorString.INVALID_FIELD_COLON
       
    93                                                + aField);
       
    94         }
       
    95         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
    96         {
       
    97             throw new UnsupportedFieldException(ErrorString.UNSUPPORTED_FIELD_COLON
       
    98                                                 + aField, aField);
       
    99         }
       
   100         case OsErrorMessage.KERR_NOT_FOUND:
       
   101         {
       
   102             throw new IndexOutOfBoundsException(ErrorString.INVALID_INDEX_COLON + aIndex);
       
   103         }
       
   104         case OsErrorMessage.KERR_TOO_BIG:
       
   105         {
       
   106             throw new IllegalArgumentException(ErrorString.INVALID_VALUE);
       
   107         }
       
   108         case OsErrorMessage.KERR_OVERFLOW:
       
   109         {
       
   110             throw new FieldFullException(ErrorString.FIELD_IS_FULL);
       
   111         }
       
   112         case OsErrorMessage.KERR_LOCKED:
       
   113         {
       
   114             throw new IllegalArgumentException(ErrorString.FIELD_IS_READ_ONLY);
       
   115         }
       
   116         case OsErrorMessage.KERR_NO_MEMORY:
       
   117         {
       
   118             throw new OutOfMemoryError();
       
   119         }
       
   120         default:
       
   121         {
       
   122             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   123         }
       
   124         }
       
   125     }
       
   126 
       
   127     public static void handleFieldHandlingError(int aNativeErrorCode, int aField)
       
   128     {
       
   129         handleFieldHandlingError(aNativeErrorCode, aField, 0);
       
   130     }
       
   131 
       
   132     // @}
       
   133 
       
   134     // @{
       
   135     /**
       
   136      * Checks given native-originating error code for category handling
       
   137      * operations and in error throws a suitable exception for that error.
       
   138      *
       
   139      * The category handling operations are present mainly in PIMListImpl and
       
   140      * PIMItemImpl classes.
       
   141      *
       
   142      * The native error codes and corresponding exceptions are listed below.
       
   143      *
       
   144      * @param aNativeErrorCode
       
   145      *            The native error code to check. For error codes other than
       
   146      *            OsErrorMessage.SUCCESS an exception is thrown.
       
   147      *
       
   148      * @param aCategory
       
   149      *            The category to mention in the exception description where
       
   150      *            applicable.
       
   151      *
       
   152      * @exception PIMException
       
   153      *                for OsErrorMessage.KERR_SESSION_CLOSED,
       
   154      *                OsErrorMessage.KERR_ARGUMENT,
       
   155      *                OsErrorMessage.KERR_NOT_SUPPORTED,
       
   156      *                OsErrorMessage.KERR_NOT_FOUND and for any other errors by
       
   157      *                default.
       
   158      */
       
   159     public static void handleCategoryHandlingError(int aNativeErrorCode,
       
   160             String aCategory) throws PIMException
       
   161     {
       
   162         if (aNativeErrorCode == OsErrorMessage.SUCCESS)
       
   163         {
       
   164             return; // OK
       
   165         }
       
   166 
       
   167         switch (aNativeErrorCode)
       
   168         {
       
   169         case OsErrorMessage.KERR_SESSION_CLOSED:
       
   170         {
       
   171             throw new PIMException(ErrorString.LIST_IS_CLOSED, PIMException.LIST_CLOSED);
       
   172         }
       
   173         case OsErrorMessage.KERR_ARGUMENT:
       
   174         {
       
   175             String msg = null;
       
   176             if (aCategory != null)
       
   177             {
       
   178                 msg = ErrorString.INVALID_CATEGORY_COLON + aCategory;
       
   179             }
       
   180             else
       
   181             {
       
   182                 msg = ErrorString.INVALID_CATEGORY;
       
   183             }
       
   184             throw new PIMException(msg, PIMException.GENERAL_ERROR);
       
   185         }
       
   186         case OsErrorMessage.KERR_NOT_FOUND:
       
   187         {
       
   188             throw new PIMException(ErrorString.NO_SUCH_CATEGORY_COLON + aCategory,
       
   189                                    PIMException.GENERAL_ERROR);
       
   190         }
       
   191         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
   192         {
       
   193             throw new PIMException(ErrorString.CATEGORIES_ARE_NOT_SUPPORTED,
       
   194                                    PIMException.FEATURE_NOT_SUPPORTED);
       
   195         }
       
   196         case OsErrorMessage.KERR_NO_MEMORY:
       
   197         {
       
   198             throw new OutOfMemoryError();
       
   199         }
       
   200         default:
       
   201         {
       
   202             throw new PIMException(ErrorString.GENERAL_ERROR,
       
   203                                    PIMException.GENERAL_ERROR);
       
   204         }
       
   205         }
       
   206     }
       
   207 
       
   208     public static void handleCategoryHandlingError(int aNativeErrorCode)
       
   209     throws PIMException
       
   210     {
       
   211         handleCategoryHandlingError(aNativeErrorCode, null);
       
   212     }
       
   213 
       
   214 
       
   215 
       
   216     public static void handleSerializationError(int aNativeErrorCode)
       
   217     throws PIMException
       
   218     {
       
   219         if (aNativeErrorCode == OsErrorMessage.SUCCESS)
       
   220         {
       
   221             return; // OK
       
   222         }
       
   223 
       
   224         switch (aNativeErrorCode)
       
   225         {
       
   226         case OsErrorMessage.KERR_NOT_FOUND:
       
   227         case OsErrorMessage.KERR_CORRUPT:
       
   228         case OsErrorMessage.KERR_TOO_BIG:
       
   229         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
   230         case OsErrorMessage.KERR_EOF:
       
   231         {
       
   232             throw new PIMException(ErrorString.DATA_SERIALIZATION_FAILED,
       
   233                                    PIMException.GENERAL_ERROR);
       
   234         }
       
   235         case OsErrorMessage.KERR_NO_MEMORY:
       
   236         {
       
   237             throw new OutOfMemoryError();
       
   238         }
       
   239         default:
       
   240         {
       
   241             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   242         }
       
   243         }
       
   244     }
       
   245 
       
   246     public static boolean checkSuccess(int aNativeErrorCode)
       
   247     {
       
   248         if (aNativeErrorCode == OsErrorMessage.SUCCESS)
       
   249         {
       
   250             return true;
       
   251         }
       
   252         return false;
       
   253     }
       
   254 
       
   255     public static boolean checkArgumentError(int aNativeErrorCode)
       
   256     {
       
   257         if (aNativeErrorCode == OsErrorMessage.KERR_ARGUMENT)
       
   258         {
       
   259             return true;
       
   260         }
       
   261         return false;
       
   262     }
       
   263 
       
   264     public static void handleRepeatRuleFieldsError(int aNativeErrorCode, int aFrequency)
       
   265     {
       
   266         switch (aNativeErrorCode)
       
   267         {
       
   268         case OsErrorMessage.SUCCESS:
       
   269         {
       
   270             return; // OK
       
   271         }
       
   272         case OsErrorMessage.KERR_ARGUMENT:
       
   273         {
       
   274             // We should never end up here because the argument is prechecked
       
   275             throw new IllegalArgumentException(ErrorString.INVALID_REPEATRULE_VALUE_COLON
       
   276                                                + aFrequency);
       
   277         }
       
   278         case OsErrorMessage.KERR_NO_MEMORY:
       
   279         {
       
   280             throw new OutOfMemoryError();
       
   281         }
       
   282         default:
       
   283         {
       
   284             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   285         }
       
   286         }
       
   287     }
       
   288 
       
   289     public static void handleItemCommitError(int aNativeErrorCode) throws PIMException
       
   290     {
       
   291         switch (aNativeErrorCode)
       
   292         {
       
   293         case OsErrorMessage.SUCCESS:
       
   294         {
       
   295             return; // OK
       
   296         }
       
   297         case OsErrorMessage.KERR_ABORT:
       
   298         {
       
   299             throw new PIMException(ErrorString.COMMIT_OPERATION_FAILED_COLON +
       
   300                                    ErrorString.ITEM_HAS_INSUFFICIENT_DATA,
       
   301                                    PIMException.GENERAL_ERROR);
       
   302         }
       
   303         case OsErrorMessage.KERR_NOT_FOUND:
       
   304         {
       
   305             throw new PIMException(ErrorString.COMMIT_OPERATION_FAILED_COLON +
       
   306                                    ErrorString.ITEM_IS_REMOVED,
       
   307                                    PIMException.GENERAL_ERROR);
       
   308         }
       
   309         case OsErrorMessage.KERR_IN_USE:
       
   310         {
       
   311             throw new PIMException(ErrorString.COMMIT_OPERATION_FAILED_COLON +
       
   312                                    ErrorString.ITEM_IN_USE,
       
   313                                    PIMException.UPDATE_ERROR);
       
   314         }
       
   315         case OsErrorMessage.KERR_DISCONNECTED:
       
   316         {
       
   317             throw new PIMException(ErrorString.COMMIT_OPERATION_FAILED_COLON +
       
   318                                    ErrorString.LIST_IS_CLOSED,
       
   319                                    PIMException.LIST_CLOSED);
       
   320         }
       
   321         case OsErrorMessage.KERR_DISMOUNTED:
       
   322         {
       
   323             throw new PIMException(ErrorString.ITEM_DOES_NOT_BELONG_TO_A_LIST,
       
   324                                    PIMException.GENERAL_ERROR);
       
   325         }
       
   326         case OsErrorMessage.KERR_NO_MEMORY:
       
   327         {
       
   328             throw new OutOfMemoryError();
       
   329         }
       
   330         default:
       
   331         {
       
   332             throw new PIMException(ErrorString.GENERAL_ERROR,
       
   333                                    PIMException.GENERAL_ERROR);
       
   334         }
       
   335         }
       
   336     }
       
   337 
       
   338     public static void handleRemoveItemError(int aNativeErrorCode) throws PIMException
       
   339     {
       
   340         switch (aNativeErrorCode)
       
   341         {
       
   342         case OsErrorMessage.SUCCESS:
       
   343         {
       
   344             return; // OK
       
   345         }
       
   346         case OsErrorMessage.KERR_SESSION_CLOSED:
       
   347         {
       
   348             throw new PIMException(ErrorString.REMOVAL_FAILED_COLON +
       
   349                                    ErrorString.LIST_IS_CLOSED,
       
   350                                    PIMException.LIST_CLOSED);
       
   351         }
       
   352         case OsErrorMessage.KERR_ARGUMENT:
       
   353         {
       
   354             // It is an interesting situation if we get here,
       
   355             // because the item _was_ found in the Java side list.
       
   356             throw new PIMException(ErrorString.REMOVAL_FAILED_COLON +
       
   357                                    ErrorString.ITEM_IS_NOT_IN_THE_LIST,
       
   358                                    PIMException.GENERAL_ERROR);
       
   359         }
       
   360         case OsErrorMessage.KERR_NOT_FOUND:
       
   361         {
       
   362             throw new PIMException(ErrorString.REMOVAL_FAILED_COLON +
       
   363                                    ErrorString.ITEM_EXISTS_NO_MORE,
       
   364                                    PIMException.GENERAL_ERROR);
       
   365         }
       
   366         case OsErrorMessage.KERR_IN_USE:
       
   367         {
       
   368             throw new PIMException(ErrorString.ITEM_IN_USE,
       
   369                                    PIMException.GENERAL_ERROR);
       
   370         }
       
   371         case OsErrorMessage.KERR_NO_MEMORY:
       
   372         {
       
   373             throw new OutOfMemoryError();
       
   374         }
       
   375         default:
       
   376         {
       
   377             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   378         }
       
   379         }
       
   380     }
       
   381 
       
   382     public static void handlePIMListCloseError(int aNativeErrorCode)
       
   383     throws PIMException
       
   384     {
       
   385         switch (aNativeErrorCode)
       
   386         {
       
   387         case OsErrorMessage.SUCCESS:
       
   388         {
       
   389             // OK
       
   390             return;
       
   391         }
       
   392         case OsErrorMessage.KERR_SESSION_CLOSED:
       
   393         {
       
   394             throw new PIMException(ErrorString.LIST_IS_ALREADY_CLOSED,
       
   395                                    PIMException.LIST_CLOSED);
       
   396         }
       
   397         default:
       
   398         {
       
   399             throw new PIMException(ErrorString.GENERAL_ERROR,
       
   400                                    PIMException.GENERAL_ERROR);
       
   401         }
       
   402         }
       
   403     }
       
   404 
       
   405     public static void handleArrayElementLabelError(int aNativeErrorCode)
       
   406     {
       
   407         switch (aNativeErrorCode)
       
   408         {
       
   409         case OsErrorMessage.SUCCESS:
       
   410         {
       
   411             // OK
       
   412             return;
       
   413         }
       
   414         case OsErrorMessage.KERR_ARGUMENT:
       
   415         {
       
   416             throw new IllegalArgumentException(ErrorString.CANNOT_OBTAIN_LABEL_COLON +
       
   417                                                ErrorString.INVALID_FIELD_OR_ARRAY_ELEMENT);
       
   418         }
       
   419         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
   420         {
       
   421             throw new UnsupportedFieldException(ErrorString.CANNOT_OBTAIN_LABEL_COLON +
       
   422                                                 ErrorString.UNSUPPORTED_FIELD_OR_ARRAY_ELEMENT);
       
   423         }
       
   424         case OsErrorMessage.KERR_NO_MEMORY:
       
   425         {
       
   426             throw new OutOfMemoryError();
       
   427         }
       
   428         default:
       
   429         {
       
   430             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   431         }
       
   432         }
       
   433     }
       
   434 
       
   435     public static void handlegetAttributeLabelError(int aNativeErrorCode,
       
   436             int aAttribute)
       
   437     {
       
   438         switch (aNativeErrorCode)
       
   439         {
       
   440         case OsErrorMessage.SUCCESS:
       
   441         {
       
   442             // OK
       
   443             return;
       
   444         }
       
   445         case OsErrorMessage.KERR_ARGUMENT:
       
   446         {
       
   447             throw new IllegalArgumentException(ErrorString.CANNOT_OBTAIN_LABEL_COLON +
       
   448                                                ErrorString.INVALID_ATTRIBUTE_COLON
       
   449                                                + aAttribute);
       
   450         }
       
   451         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
   452         {
       
   453             throw new UnsupportedFieldException(ErrorString.CANNOT_OBTAIN_LABEL_COLON +
       
   454                                                 ErrorString.UNSUPPORTED_ATTRIBUTE_COLON
       
   455                                                 + aAttribute, aAttribute);
       
   456         }
       
   457         case OsErrorMessage.KERR_NO_MEMORY:
       
   458         {
       
   459             throw new OutOfMemoryError();
       
   460         }
       
   461         default:
       
   462         {
       
   463             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   464         }
       
   465         }
       
   466     }
       
   467 
       
   468     public static void handleUpdateListError(int aNativeErrorCode) throws PIMException
       
   469     {
       
   470         switch (aNativeErrorCode)
       
   471         {
       
   472         case OsErrorMessage.SUCCESS:
       
   473         {
       
   474             // OK
       
   475             return;
       
   476         }
       
   477         case OsErrorMessage.KERR_SESSION_CLOSED:
       
   478         {
       
   479             throw new PIMException(ErrorString.UPDATING_FAILED +
       
   480                                    ErrorString.LIST_IS_CLOSED,
       
   481                                    PIMException.LIST_CLOSED);
       
   482         }
       
   483         case OsErrorMessage.KERR_NO_MEMORY:
       
   484             // fall to default
       
   485         case OsErrorMessage.KERR_CORRUPT:
       
   486             // fall to default
       
   487         default:
       
   488         {
       
   489             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   490         }
       
   491         }
       
   492     }
       
   493 
       
   494     public static void handleProcessItemResultsError(int aNativeErrorCode)
       
   495     throws PIMException
       
   496     {
       
   497         switch (aNativeErrorCode)
       
   498         {
       
   499         case OsErrorMessage.SUCCESS:
       
   500         {
       
   501             // OK
       
   502             break;
       
   503         }
       
   504         case OsErrorMessage.KERR_SESSION_CLOSED:
       
   505         {
       
   506             throw new PIMException(ErrorString.LIST_IS_CLOSED,
       
   507                                    PIMException.LIST_CLOSED);
       
   508         }
       
   509         case OsErrorMessage.KERR_ARGUMENT:
       
   510         {
       
   511             throw new IllegalArgumentException(ErrorString.INVALID_ARGUMENT);
       
   512         }
       
   513         case OsErrorMessage.KERR_NO_MEMORY:
       
   514         {
       
   515             throw new OutOfMemoryError();
       
   516         }
       
   517         default:
       
   518         {
       
   519             throw new PIMException(ErrorString.GENERAL_ERROR,
       
   520                                    PIMException.GENERAL_ERROR);
       
   521         }
       
   522         }
       
   523     }
       
   524 
       
   525     public static void handleListPIMListError(int aNativeErrorCode)
       
   526     {
       
   527         switch (aNativeErrorCode)
       
   528         {
       
   529         case OsErrorMessage.SUCCESS:
       
   530         {
       
   531             // OK
       
   532             return;
       
   533         }
       
   534         case OsErrorMessage.KERR_ARGUMENT:
       
   535         {
       
   536             // Shouldn't happen because arguments are prechecked
       
   537             throw new java.lang.IllegalArgumentException(ErrorString.INVALID_ARGUMENT);
       
   538         }
       
   539         case OsErrorMessage.KERR_NO_MEMORY:
       
   540         {
       
   541             throw new OutOfMemoryError();
       
   542         }
       
   543         default:
       
   544         {
       
   545             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   546         }
       
   547         }
       
   548     }
       
   549 
       
   550     public static void handleOpenPIMListError(int aNativeErrorCode, int aPimListType,
       
   551             String aName) throws PIMException
       
   552     {
       
   553         switch (aNativeErrorCode)
       
   554         {
       
   555             // error code
       
   556         case OsErrorMessage.SUCCESS:
       
   557         {
       
   558             // OK
       
   559             return;
       
   560         }
       
   561         case OsErrorMessage.KERR_ARGUMENT:
       
   562         {
       
   563             // This should never happen, because the arguments
       
   564             // have been pre-checked before delegation to native side
       
   565             throw new java.lang.IllegalArgumentException(ErrorString.INVALID_ARGUMENT);
       
   566         }
       
   567         case OsErrorMessage.KERR_NOT_SUPPORTED:
       
   568         {
       
   569             throw new PIMException("List type " + aPimListType
       
   570                                    + " is not supported.", PIMException.FEATURE_NOT_SUPPORTED);
       
   571         }
       
   572         case OsErrorMessage.KERR_NOT_FOUND:
       
   573         {
       
   574             throw new PIMException(ErrorString.INVALID_LIST_NAME_COLON + aName,
       
   575                                    PIMException.GENERAL_ERROR);
       
   576         }
       
   577         case OsErrorMessage.KERR_ALREADY_EXISTS:
       
   578         {
       
   579             throw new PIMException(ErrorString.LIST_IS_ALREADY_OPEN,
       
   580                                    PIMException.GENERAL_ERROR);
       
   581         }
       
   582         case OsErrorMessage.KERR_NO_MEMORY:
       
   583         {
       
   584             throw new OutOfMemoryError();
       
   585         }
       
   586         default:
       
   587         {
       
   588             throw new PIMException(ErrorString.GENERAL_ERROR,
       
   589                                    PIMException.GENERAL_ERROR);
       
   590         }
       
   591         }
       
   592     }
       
   593 
       
   594     public static void handleToSerialFormatError(int aNativeErrorCode)
       
   595     throws PIMException
       
   596     {
       
   597         if (aNativeErrorCode == OsErrorMessage.KERR_NO_MEMORY)
       
   598         {
       
   599             throw new OutOfMemoryError();
       
   600         }
       
   601         else if (aNativeErrorCode != OsErrorMessage.SUCCESS)
       
   602         {
       
   603             throw new PIMException(ErrorString.DATA_SERIALIZATION_FAILED_COLON +
       
   604                                    ErrorString.ITEM_HAS_INVALID_DATA,
       
   605                                    PIMException.GENERAL_ERROR);
       
   606         }
       
   607     }
       
   608 
       
   609     /**
       
   610      * Common native-originating error handling for RepeatRule field handling
       
   611      * operations. Note that error handling for RepeatRule field handling
       
   612      * operations differ from those in PIMItem and PIMList.
       
   613      */
       
   614     public static void handleRRFieldHandlingError(int aNativeErrorCode,
       
   615             int aField)
       
   616     {
       
   617         if (aNativeErrorCode == OsErrorMessage.SUCCESS)
       
   618         {
       
   619             return; // OK
       
   620         }
       
   621 
       
   622         switch (aNativeErrorCode)
       
   623         {
       
   624         case OsErrorMessage.KERR_ARGUMENT:
       
   625         {
       
   626             throw new IllegalArgumentException(ErrorString.INVALID_FIELD_COLON
       
   627                                                + aField);
       
   628         }
       
   629         case OsErrorMessage.KERR_NOT_FOUND:
       
   630         {
       
   631             throw new FieldEmptyException(ErrorString.FIELD_NOT_FOUND_COLON + aField);
       
   632         }
       
   633         case OsErrorMessage.KERR_TOO_BIG:
       
   634         {
       
   635             throw new IllegalArgumentException(ErrorString.INVALID_VALUE);
       
   636         }
       
   637         case OsErrorMessage.KERR_NO_MEMORY:
       
   638         {
       
   639             throw new OutOfMemoryError();
       
   640         }
       
   641         default:
       
   642         {
       
   643             throw new GenericException(ErrorString.GENERAL_ERROR_COLON + aNativeErrorCode);
       
   644         }
       
   645         }
       
   646     }
       
   647 
       
   648     /**
       
   649      * Construction prohibited.
       
   650      */
       
   651     private NativeError()
       
   652     {
       
   653     }
       
   654 
       
   655 }