MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/utilitylibraries/libutils/src/chartodescriptor16.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     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 char * to Descriptor16 conversions

    15  *

    16 */

    17 

    18 

    19 

    20 #include "libutils.h"

    21   

    22 

    23 /** 

    24   * Converts a character stream to TBuf16

    25   * 

    26   * @param aSrc is char*, aDes is the reference to the descriptor

    27   * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, -4 is EInvalidPointer, -7 is EInvalidMBSSequence)

    28   */

    29      

    30 EXPORT_C  int CharToTbuf16(const char* aSrc, TDes16& aDes)

    31 {		

    32     int retval = ESuccess;

    33     unsigned int ilen = 0;

    34     int minusone = -1;

    35 

    36 	    

    37 	if (!aSrc)

    38 	{	

    39 	    return EInvalidPointer;	

    40 	}	

    41 	else 

    42 	{	

    43 	    ilen = strlen(aSrc);

    44 	    if(ilen > aDes.MaxLength())

    45 	    {

    46 	        return EInsufficientMemory;	

    47 	    }	

    48 	}    

    49     wchar_t *WcharString = new wchar_t[ilen+1];

    50     if(!WcharString)

    51     {

    52     	return EInsufficientSystemMemory;

    53     }

    54             

    55 	if(minusone == mbstowcs(WcharString, (const char*)aSrc, ilen))

    56 	{   

    57 		retval = EInvalidMBSSequence;

    58 	}

    59 	else 

    60 	{

    61 		aDes.Copy((unsigned short *)WcharString, ilen);

    62 	}   

    63         

    64 	delete[] WcharString;

    65 	return retval;

    66 }

    67 

    68    /**

    69      * Converts a character stream to HBufc16

    70      * 

    71      * @param aSrc is char*, aDes is the reference to the descriptor

    72      * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, -4 is EInvalidPointer, -6 is EUseNewMaxL, -7 is EInvalidMBSSequence)

    73      */

    74      

    75 EXPORT_C int CharToHbufc16(const char* aSrc, HBufC16* aDes)

    76 {	

    77 	int retval = ESuccess; 

    78 	unsigned int ilen = 0, ilendes = 0; 

    79 	int minusone = -1;

    80 	if (!aSrc || !aDes)

    81 	{

    82 		return EInvalidPointer;

    83 	}

    84 	else 

    85 	{

    86 	    ilen = strlen (aSrc);

    87 	    ilendes = aDes->Length();

    88 	    

    89 	    if(0 == ilendes)

    90 	    {

    91 	        return EUseNewMaxL;	

    92 	    }     

    93 	    else if (ilen > ilendes)

    94 	    {

    95 	    	return EInsufficientMemory;	

    96 	    }	

    97 	}

    98 	

    99 	wchar_t *wCharString = new wchar_t[ilen+1];

   100 	

   101 	if (!wCharString)

   102 	{

   103 		return EInsufficientMemory;

   104 	}

   105 	

   106 	if(minusone == mbstowcs((wchar_t *)wCharString, (const char*)aSrc, ilen))

   107 	{

   108 		retval = EInvalidMBSSequence;

   109 	}

   110 	else 

   111 	{

   112 	    wCharString[ilen] = (wchar_t)'\0';

   113 		TPtrC16 temp ((unsigned short *)wCharString, ilen);

   114 		*aDes = temp; 

   115 	}

   116 	

   117 	delete[] wCharString;

   118 	return retval;

   119 }

   120 

   121 /**

   122   * Converts a character stream to TPtr16

   123   *

   124   * @param aSrc is char*, wPtr is wchar_t*, aDes is the reference to the descriptor

   125   * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, -4 is EInvalidPointer, -7 is EInvalidMBSSequence)

   126   */

   127      

   128 EXPORT_C int CharpToTptr16(const char* aSrc, TPtr16& aDes)

   129 {

   130     int retval = ESuccess;

   131     unsigned int ilen =0 , ilendes = 0;

   132     int minusone = -1;

   133     

   134 	if (!aSrc)

   135 	{

   136 		return EInvalidPointer;

   137 	}

   138 	else 

   139 	{

   140 	    ilen = strlen(aSrc);

   141 	    ilendes = aDes.MaxLength();

   142 	    

   143 	    if (ilendes < ilen)

   144 	    {

   145 	    	return EInsufficientMemory;

   146 	    }

   147 	}

   148 	

   149   wchar_t *wPtr = new wchar_t[ilen+1];

   150 	

   151 	if (!wPtr)

   152 	{

   153 		return EInsufficientMemory;

   154 	}

   155 	

   156 	if(minusone != mbstowcs((wchar_t *)wPtr, (const char*)aSrc, ilen ))

   157 	{

   158 		aDes.Copy((unsigned short *)wPtr, ilen);

   159 	}

   160 	else

   161 	{

   162 		retval = EInvalidMBSSequence;

   163 	}

   164 	

   165 	delete[] wPtr;

   166 	return retval;

   167 }

   168 

   169 /**

   170   * Converts a character stream to TPtrc16

   171   *

   172   * @param aSrc is char*, cPtr is wchar_t*, aDes is the reference to the descriptor

   173   * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, -4 is EInvalidPointer, -7 is EInvalidMBSSequence)

   174   */

   175      

   176 EXPORT_C int CharpToTptrc16(char* aSrc ,wchar_t* cPtr, TPtrC16& aDes)

   177 {

   178     int retval = ESuccess; 

   179     unsigned int ilen = 0;

   180     int minusone = -1;

   181     

   182 	if ( !aSrc || !cPtr )

   183 	{

   184 		return EInvalidPointer;

   185 	}

   186 	

   187 	ilen = strlen(aSrc);

   188 

   189 	if(minusone != mbstowcs((wchar_t*)cPtr, (const char*)aSrc, strlen(aSrc)))

   190 	{

   191 	    aDes.Set((TUint16*)cPtr, ilen);

   192 	}

   193 	else

   194 	{

   195 	    retval = EInvalidMBSSequence;

   196 	}

   197 	

   198 	return retval; 

   199 }

   200 

   201 /**

   202   * Converts a character stream to RBuf16

   203   * 

   204   * @param aSrc is char*, aDes is the reference to the descriptor

   205   * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, -4 is EInvalidPointer, -7 is EInvalidMBSSequence)

   206   */

   207   

   208   

   209 EXPORT_C int CharToRbuf16(const char* aSrc, RBuf16& aDes)

   210 {

   211     int retval = ESuccess;

   212     unsigned int ilen = 0; 

   213     int minusone = -1;

   214     if ( !aSrc )

   215     {

   216     	return EInvalidPointer;

   217     }

   218     ilen = strlen(aSrc);

   219 	

   220 	wchar_t* buf = new wchar_t[ilen];

   221     if (!buf)

   222     {

   223     	return EInsufficientSystemMemory;

   224     }

   225     

   226 	if(minusone != mbstowcs(buf, aSrc, ilen))

   227 	{

   228 	    aDes.Copy((const unsigned short *)buf, ilen);	

   229 	}   

   230 	else

   231 	{

   232 		retval = EInvalidMBSSequence;

   233 	}

   234 	

   235 	delete []buf;

   236 	return retval;

   237 }
Symaptic