MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/utilitylibraries/libutils/src/descriptor8towchar.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     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:   Contains the source for Descriptor8 to wchar * conversions

    15  *

    16 */

    17 

    18 

    19 

    20 #include "libutils.h"

    21   

    22 

    23 

    24  /**

    25    * Converts a descriptor of type TBuf8 to wchar

    26    *

    27    * @param aSrc is the descriptor to be converted , aDes is the 

    28    * reference to the wchar array where the result of conversion 

    29    * is stored  

    30    * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

    31    *  -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

    32    */

    33    

    34 EXPORT_C int Tbuf8ToWchar(TDes8& aSrc, wchar_t* aDes, int& n_size)

    35 {	

    36     int retval = ESuccess;	

    37     unsigned int ilen = aSrc.Length();

    38     int minusone = -1;

    39     

    40     if(0 == ilen)

    41     {

    42     	return EDescriptorNoData;

    43     }

    44     else if(!aDes)

    45     {

    46     	return EInvalidPointer;

    47     }

    48     else if(n_size < ilen+1)

    49     {	

    50         n_size = ilen+1; 

    51     	return EInvalidSize;

    52     }	

    53 	

    54 	if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen))

    55 	{

    56 	    *(aDes + ilen) = L'\0';	

    57 	}

    58 	else 

    59 	{

    60 		retval = EInvalidMBSSequence;

    61 	}

    62 	

    63 	return retval;			

    64 }		

    65 		

    66  /**

    67    * Converts a descriptor of type TBufc8 to wchar

    68    *

    69    * @param aSrc is the descriptor to be converted , aDes is the 

    70    * reference to the wchar array where the result of conversion 

    71    * is stored  

    72    * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

    73    *  -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

    74    */

    75 

    76 EXPORT_C int Tbufc8ToWchar(TDesC8& aSrc, wchar_t* aDes, int& n_size)

    77 {

    78     int retval = ESuccess;

    79     unsigned int ilen = aSrc.Length();

    80     int minusone = -1;

    81     

    82     if(0 == ilen)

    83     {

    84     	return EDescriptorNoData;

    85     }

    86     else if(!aDes)

    87     {

    88     	return EInvalidPointer;

    89     }

    90     else if (n_size < ilen+1)

    91 	{

    92 		n_size = ilen+1;

    93 		return EInvalidSize;

    94 	}

    95 	

    96 	if(minusone != mbstowcs(aDes, (const char *)aSrc.Ptr(), ilen))

    97 	{

    98 		aDes[ilen] = L'\0';

    99 	}

   100 	else 

   101 	{

   102 		retval = EInvalidMBSSequence;

   103 	}

   104 	

   105 	return retval;

   106 }

   107 

   108  /**

   109    * Converts a descriptor of type TLitc8 to wchar

   110    *

   111    * @param aSrc is the descriptor to be converted , aDes is the 

   112    * reference to the wchar array where the result of conversion 

   113    * is stored  

   114    * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

   115    *  -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

   116    */

   117 

   118 EXPORT_C int Tlitc8ToWchar( const TDesC8& aSrc, wchar_t* aDes, int& n_size)

   119 { 

   120     int retval = ESuccess;

   121     unsigned int ilen = aSrc.Length();

   122     int minusone = -1;

   123     

   124     if (0 == ilen )

   125     {

   126     	return EDescriptorNoData;

   127     }

   128     else if ( !aDes )

   129     {

   130     	return EInvalidPointer;

   131     }

   132     else if (n_size < ilen+1)

   133     {

   134 		n_size = ilen+1 ;

   135 		return EInvalidSize;    	

   136     }

   137 	

   138 	if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen ))

   139 	{

   140 	    aDes[ilen] = L'\0'; 

   141 	}

   142 	else 

   143 	{

   144 		retval = EInvalidMBSSequence;

   145 	}

   146 	

   147 	return retval;	

   148 }

   149 

   150  /**

   151    *Converts a descriptor of type TPtr8 to Wchar

   152    *@param aSrc is the descriptor to be converted , aDes is the 

   153    *reference to the wchar array where the result of conversion 

   154    *is stored  

   155    *@return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

   156    * -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

   157    */

   158 

   159 EXPORT_C int Tptr8ToWcharp(const TPtr8& aSrc, wchar_t* aDes, int& n_size)

   160 {

   161    

   162     int retval = ESuccess;

   163     unsigned int ilen = aSrc.Length();

   164     int minusone = -1;

   165     

   166     if (0 == ilen)

   167     {

   168     	return EDescriptorNoData;

   169     }

   170     else if(!aDes)

   171     {

   172     	return EInvalidPointer;

   173     } 

   174 	else if(n_size < ilen+1)

   175     {

   176         n_size = ilen+1 ;

   177     	return EInvalidSize;

   178     }

   179 	

   180 	if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen))

   181 	{

   182 	    aDes[ilen] = L'\0';

   183 	}

   184 	else 

   185 	{

   186 		retval = EInvalidMBSSequence;

   187 	}

   188 	

   189 	return retval;

   190 }

   191 

   192  /**

   193    *Converts a descriptor of type TPtrc to Wchar

   194    *

   195    *@param aSrc is the descriptor to be converted , aDes is the 

   196    *reference to the wchar array where the result of conversion 

   197    *is stored  

   198    *@return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

   199    * -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

   200    */

   201 

   202 EXPORT_C int Tptrc8ToWcharp(TPtrC8& aSrc, wchar_t* aDes, int& n_size)

   203 {

   204     int retval = ESuccess;

   205     unsigned int ilen = aSrc.Length();

   206     int minusone = -1;

   207     

   208     if (0 == ilen)

   209     {

   210     	return EDescriptorNoData;

   211     }

   212     else if(!aDes)

   213     {

   214     	return EInvalidPointer;

   215     }

   216 	else if(n_size < ilen)

   217 	{

   218 		n_size = ilen;

   219 		return EInvalidSize;

   220 	}

   221 	

   222 	if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen))

   223 	{

   224 	    aDes[ilen] = L'\0';

   225 	}

   226 	else 

   227 	{

   228 		retval = EInvalidMBSSequence;

   229 	}

   230 	

   231 	return retval;	

   232 }

   233 

   234  /**

   235    *Converts a descriptor of type Rbuf8 to Wchar

   236    *

   237    *@param aSrc is the descriptor to be converted , aDes is the 

   238    *reference to the wchar array where the result of conversion 

   239    *is stored  

   240    *@return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

   241    * -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

   242    */

   243 

   244 EXPORT_C int Rbuf8ToWchar(TDes8& aSrc, wchar_t* aDes, int& n_size)

   245 {

   246     int retval = ESuccess;

   247     unsigned int ilen = aSrc.Length();

   248     int minusone = -1;

   249     

   250     if (0 == ilen )

   251     {

   252     	return EDescriptorNoData;

   253     }

   254     else if(!aDes)

   255     {

   256     	return EInvalidPointer;

   257     }

   258     else if (n_size < ilen)

   259 	{

   260 		n_size = ilen + 1;

   261 		return EInvalidSize;

   262 	}

   263 	

   264 	if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen))

   265 	{

   266 		*(aDes + ilen) = L'\0';

   267 	}

   268 	else

   269 	{

   270 		retval = EInvalidMBSSequence;

   271 	}

   272 			

   273 	return retval;

   274 }

   275 

   276 /**

   277    *Converts a descriptor of type Rbuf8 to Wchar

   278    *

   279    *@param aSrc is the descriptor to be converted , aDes is the 

   280    *reference to the wchar array where the result of conversion 

   281    *is stored  

   282    *@return Status code (0 is ESuccess, -1 is EInsufficientMemory, 

   283    * -2 is EInvalidSize , -4 is EInvalidPointer , -5 is EDescriptorNoData)

   284    */

   285 

   286 EXPORT_C int HBufc8ToWchar(HBufC8* aSrc, wchar_t* aDes, int& n_size)

   287 {

   288     int retval = ESuccess;

   289     unsigned int ilen = 0;

   290     int minusone = -1;

   291     

   292     if(!aDes || !aSrc)

   293     {

   294     	return EInvalidPointer;

   295     }

   296     else

   297     {

   298     	int ilen = aSrc->Length();

   299     	if (0 == ilen )

   300         {

   301     	    return EDescriptorNoData;

   302         }

   303         else if (n_size < ilen)

   304 	    {

   305 		    n_size = ilen + 1;

   306 		    return EInvalidSize;

   307 	    }

   308     }

   309     

   310 	if(minusone != mbstowcs(aDes, (const char*)aSrc->Ptr(), ilen))

   311 	{

   312 		*(aDes + ilen) = L'\0';

   313 	}

   314 	else

   315 	{

   316 		retval = EInvalidMBSSequence;

   317 	}

   318 			

   319 	return retval;

   320 }
Symaptic