Symaptic: os/ossrv/utilitylibraries/libutils/src/descriptor16tostring.cpp@260cb5ec6c19

     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 Descriptor16 to string conversions

    15  *

    16 */

    20 #include "libutils.h"

    24  /**

    25    * Converts a descriptor of type TBuf16 to string datatype

    26    *

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

    28    * reference to the string to which the result of conversion

    29    * is stored ,

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

    31    */

    33 EXPORT_C int Tbuf16ToString(TDes16& aSrc, string& aDes)

    34 {

    35     unsigned int ilen = aSrc.Length();

    36     int retval = ESuccess;

    37     int minusone = -1;

    38     char* charString = new char[ilen*2+1];

    40     if (!charString)

    41     {

    42     	return EInsufficientSystemMemory;

    43     }

    45     wchar_t *wcharString = new wchar_t[ilen+1];

    47     if (!wcharString)

    48     {

    49     	delete []charString;

    50     	return EInsufficientSystemMemory;

    51     }

    53     wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

    54     wcharString[ilen] = L'\0';

    56     if(minusone != wcstombs(charString, wcharString, ilen*2))

    57     {

    58     	charString[ilen*2] = '\0';

    59         aDes.assign(charString);

    60     }

    61     else

    62     {

    63     	retval = EInvalidWCSSequence;

    64     }

    66     delete []charString;

    67 	delete []wcharString;

    69 	return retval;

    70 }

    72  /**

    73    * Converts a descriptor of type TBufC16 to string datatype

    74    *

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

    76    * reference to the string to which the result of conversion

    77    * is stored ,

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

    79    */

    81 EXPORT_C int Tbufc16ToString(TDesC16& aSrc, string& aDes)

    82 {

    83     int ilen = aSrc.Length(), retval = ESuccess;

    84     int minusone = -1;

    85     char* charString = new char[ilen*2+1];

    87     if (!charString)

    88     {

    89     	return EInsufficientSystemMemory;

    90     }

    92     wchar_t *wcharString = new wchar_t[ilen+1];

    94     if (!wcharString)

    95     {

    96     	delete []charString;

    97     	return EInsufficientSystemMemory;

    98     }

   100     wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

   101     wcharString[ilen] = L'\0';

   103     if(minusone != wcstombs(charString, wcharString, ilen*2))

   104     {

   105     	charString[ilen*2] = '\0';

   106         aDes.assign(charString);

   107     }

   108     else

   109     {

   110     	retval = EInvalidWCSSequence;

   111     }

   113     delete []charString;

   114 	delete []wcharString;

   116 	return retval;

   117 }

   119  /**

   120    * Converts a descriptor of type TPtr16 to string datatype

   121    *

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

   123    * reference to the string to which the result of conversion

   124    * is stored ,

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

   126    */

   128 EXPORT_C int Tptr16ToString (TDes16& aSrc, string& aDes)

   129 {

   130     int retval = ESuccess;

   131     unsigned int ilen= aSrc.Length();

   132 	  int minusone = -1;

   133 	  char* charString = new char[ilen*2+1];

   135 	  if (!charString)

   136     {

   137     	return EInsufficientSystemMemory;

   138     }

   139     wchar_t *wcharString = new wchar_t[ilen+1];

   141     if (!wcharString)

   142     {

   143     	delete []charString;

   144     	return EInsufficientSystemMemory;

   145     }

   147     wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

   148     wcharString[ilen] = L'\0';

   151 	if(minusone != wcstombs(charString, wcharString, ilen*2))

   152 	{

   153 	    charString[ilen*2] = '\0';

   154 		aDes.assign(charString);

   155 	}

   156 	else

   157 	{

   158 		retval = EInvalidWCSSequence;

   159 	}

   161 	delete []charString;

   162 	delete []wcharString;

   164 	return retval;

   165 }

   167  /**

   168    * Converts a descriptor of type TPtrC16 to string datatype

   169    *

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

   171    * reference to the string to which the result of conversion

   172    * is stored ,

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

   174    */

   176 EXPORT_C int Tptrc16ToString (const TDesC16& aSrc, string& aDes)

   177 {

   178     int retval = ESuccess;

   179 	  int ilen= aSrc.Length();

   180 	  int minusone = -1;

   181 	  char* buf = new char[ilen*2 +1];

   183 	  if (!buf)

   184     {

   185     	return EInsufficientSystemMemory;

   186     }

   188     wchar_t *wcharString = new wchar_t[ilen+1];

   190     if (!wcharString)

   191     {

   192     	delete []buf;

   193     	return EInsufficientSystemMemory;

   194     }

   196     wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

   197     wcharString[ilen] = L'\0';

   199 	if(minusone != wcstombs(buf, wcharString, ilen*2))

   200 	{

   201 	    buf[ilen*2] = '\0';

   202 		aDes.assign(buf);

   203 	}

   204 	else

   205 	{

   206 		retval =  EInvalidWCSSequence;

   207 	}

   209 	delete []buf;

   210 	delete []wcharString;

   212 	return retval;

   213 }

   215  /**

   216    * Converts a descriptor of type HbufC16 to string datatype

   217    *

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

   219    * reference to the string to which the result of conversion

   220    * is stored , n_size specifies the conversion size of the string

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

   222    * -2 is EInvalidSize , -5 is EDescriptorNoData)

   223    */

   225 EXPORT_C int Hbufc16ToString(HBufC16* aSrc, string& aDes, int& n_size)

   226 {

   227     int retval = ESuccess;

   228     unsigned int ilen=0;

   229     int minusone = -1;

   231   	if(!aSrc)

   232     {

   233     	return EInvalidPointer;

   234     }

   235     else

   236     {

   237     	ilen = aSrc->Size();

   238     	if (0 == ilen)

   239     	{

   240     		return EDescriptorNoData;

   241     	}

   242     	else if (n_size < ilen)

   243     	{

   244     		n_size = ilen;

   245     		return EInvalidSize;

   246     	}

   247     }

   249 	  char* buf = new char[ilen*2 +1];

   251 	  if (!buf)

   252     {

   253     	return EInsufficientSystemMemory;

   254     }

   256     wchar_t *wcharString = new wchar_t[ilen+1];

   258     if (!wcharString)

   259     {

   260     	delete []buf;

   261     	return EInsufficientSystemMemory;

   262     }

   264     wmemcpy(wcharString, (const wchar_t*)aSrc->Ptr(), ilen);

   265     wcharString[ilen] = L'\0';

   268 	if(minusone != wcstombs(buf, wcharString, ilen*2))

   269 	{

   270 	    buf[ilen*2] = '\0';

   271 	    aDes.assign(buf, ilen*2);

   273 	}

   274 	else

   275 	{

   276 		retval = EInvalidWCSSequence;

   277 	}

   279 	delete []buf;

   280 	delete []wcharString;

   282 	return retval;

   283 }

   285  /**

   286    * Converts a descriptor of type RBuf16 to string datatype

   287    *

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

   289    * reference to the string to which the result of conversion

   290    * is stored ,

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

   292    * -5 is EDescriptorNoData)

   293    */

   295 EXPORT_C int Rbuf16ToString(TDes16& aSrc, string& aDes)

   296 {

   297     unsigned int ilen = aSrc.Length();

   298     int retval = ESuccess ;

   299     int minusone = -1;

   300     if (0 == ilen)

   301     {

   302     	return EDescriptorNoData;

   303     }

   305     char* buf = new char[ilen*2 +1];

   307     if (!buf)

   308     {

   309     	return EInsufficientSystemMemory;

   310     }

   312     wchar_t *wcharString = new wchar_t[ilen+1];

   314     if (!wcharString)

   315     {

   316     	delete []buf;

   317     	return EInsufficientSystemMemory;

   318     }

   320     wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

   321     wcharString[ilen] = L'\0';

   324     if(minusone != wcstombs(buf, wcharString, ilen*2))

   325 	{

   326 	    buf[ilen*2] = '\0';

   327 	    aDes.assign(buf, ilen*2);

   329 	}

   330 	else

   331 	{

   332 		retval = EInvalidWCSSequence;

   333 	}

   335     delete []buf;

   336     delete []wcharString;

   338 	return retval;

   339 }

   341  /**

   342    * Converts a descriptor of type TLit16 to string datatype

   343    *

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

   345    * reference to the string to which the result of conversion

   346    * is stored ,

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

   348    * -5 is EDescriptorNoData)

   349    */

   351 EXPORT_C int Tlit16ToString(const TDesC16& aSrc, string& aDes)

   352 {

   353    unsigned int ilen = 0;

   354    int retval = ESuccess;

   355    ilen = aSrc.Length();

   356    int minusone = -1;

   358    if (0 == ilen)

   359    {

   360    		return EDescriptorNoData;

   361    }

   363    char* buf = new char[ilen*2 +1];

   365    if (!buf)

   366    {

   367        return EInsufficientSystemMemory;

   368    }

   370    wchar_t *wcharString = new wchar_t[ilen+1];

   372    if (!wcharString)

   373    {

   374    	   delete []buf;

   375        return EInsufficientSystemMemory;

   376    }

   378    wmemcpy(wcharString, (const wchar_t*)aSrc.Ptr(), ilen);

   379    wcharString[ilen] = L'\0';

   382    if(minusone != wcstombs(buf, wcharString, ilen*2))

   383    {

   384  	    buf[ilen*2] = '\0';

   385  	    aDes.assign(buf);

   387    }

   388    else

   389    {

   390 	    retval = EInvalidWCSSequence;

   391    }

   393    delete []buf;

   394    delete []wcharString;

   395    return retval;

   396 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--