Symaptic: os/ossrv/utilitylibraries/libutils/src/descriptor16towchar.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 wchar * conversions

    15  *

    16 */

    20 #include "libutils.h"

    24  /**

    25    * Converts a descriptor of type TBuf16 to WChar

    26    *

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

    28    * reference to the WChar stream where the result of conversion

    29    * is stored , n_size specifies the conversion size of the WChar

    30    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

    31    * -4 is EInvalidPointer)

    32    */

    34 EXPORT_C int Tbuf16ToWchar(const TDes16& aSrc, wchar_t* aDes, int& n_size)

    35 {

    36     unsigned int ilen = aSrc.Length();

    38     if (0 == ilen)

    39     {

    40     	return EDescriptorNoData;

    41     }

    42     else if (!aDes)

    43     {

    44     	return EInvalidPointer;

    45     }

    46 	else if(n_size < (ilen+1))

    47 	{

    48 		n_size = ilen + 1;

    49 		return EInvalidSize;

    50 	}

    52 	wmemcpy(aDes , (const wchar_t*)aSrc.Ptr(), ilen);

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

    55 	return ESuccess;

    56 }

    58 /**

    59    * Converts a descriptor of type HBufC16 to WChar

    60    *

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

    62    * reference to the WChar stream where the result of conversion

    63    * is stored , n_size specifies the conversion size of the WChar

    64    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

    65    * -4 is EInvalidPointer)

    66    */

    68 EXPORT_C int Hbufc16ToWchar(const HBufC16* aSrc, wchar_t* aDes, int& n_size)

    69 {

    70     unsigned int ilen = 0;

    71     if (!aSrc || !aDes)

    72     {

    73     	return EInvalidPointer;

    74     }

    75     else

    76     {

    77         ilen = aSrc->Length();

    79         if (0 == ilen)

    80         {

    81     	    return EDescriptorNoData;

    82         }

    83         else if(n_size < (ilen+1))

    84 	    {

    85 		    n_size = ilen + 1;

    86 		    return EInvalidSize;

    87 	    }

    88     }

    90 	wmemcpy(aDes , (const wchar_t*)aSrc->Ptr(), ilen);

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

    93 	return ESuccess;

    94 }

    97  /**

    98    * Converts a descriptor of type TBufC16 to WChar

    99    *

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

   101    * reference to the WChar stream where the result of conversion

   102    * is stored , n_size specifies the conversion size of the WChar

   103    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

   104    * -4 is EInvalidPointer)

   105    */

   107 EXPORT_C int Tbufc16ToWchar(TDesC& aSrc, wchar_t* aDes, int& n_size)

   108 {

   109     unsigned int ilen = aSrc.Length();

   111     if (0 == ilen)

   112     {

   113     	return EDescriptorNoData;

   114     }

   115     else if (!aDes)

   116     {

   117     	return EInvalidPointer;

   118     }

   119 	if (n_size < (ilen+1))

   120 	{

   121 		n_size = ilen+1;

   122 		return EInvalidSize;

   123 	}

   125 	wmemcpy(aDes, (wchar_t *)aSrc.Ptr(), ilen);

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

   128 	return ESuccess;

   129 }

   132  /**

   133    * Converts a descriptor of type TLitC16 to WChar

   134    *

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

   136    * reference to the WChar stream where the result of conversion

   137    * is stored , n_size specifies the conversion size of the WChar

   138    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

   139    * -4 is EInvalidPointer)

   140    */

   141 EXPORT_C int Tlitc16ToWchar(const TDesC16& aSrc, wchar_t* aDes, int& n_size)

   142 {

   143     unsigned int ilen = aSrc.Length();

   145     if (0 == ilen)

   146     {

   147     	return EDescriptorNoData;

   148     }

   149     else if ( !aDes )

   150     {

   151     	return EInvalidPointer;

   152     }

   153     else if (n_size < (ilen+1))

   154     {

   155 		n_size = ilen+11 ;

   156 		return EInvalidSize;

   157     }

   159 	wmemcpy(aDes , (const wchar_t*)aSrc.Ptr(), ilen);

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

   162     return ESuccess;

   164 }

   166  /**

   167    * Converts a descriptor of type TPtr16 to WChar

   168    *

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

   170    * reference to the WChar stream where the result of conversion

   171    * is stored , n_size specifies the conversion length of the WChar

   172    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

   173    * -4 is EInvalidPointer)

   174    */

   176 EXPORT_C int Tptr16ToWcharp(const TPtr16& aSrc ,wchar_t* aDes, int& n_size)

   177 {

   178     unsigned int ilen = aSrc.Length();

   180     if (0 == ilen)

   181     {

   182     	return EDescriptorNoData;

   183     }

   184     else if(!aDes)

   185     {

   186     	return EInvalidPointer;

   187     }

   188 	else if(n_size < ilen)

   189 	{

   190 		n_size = ilen;

   191 		return EInvalidSize;

   192 	}

   194 	wmemcpy(aDes, (const wchar_t*)aSrc.Ptr(), ilen);

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

   197 	return ESuccess;

   198 }

   200  /**

   201    * Converts a descriptor of type TPtrC16 to WChar

   202    *

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

   204    * reference to the WChar stream where the result of conversion

   205    * is stored , n_size specifies the conversion length of the WChar

   206    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

   207    * -4 is EInvalidPointer)

   208    */

   210 EXPORT_C int Tptrc16ToWcharp(TPtrC16& aSrc, wchar_t* aDes, int& n_size)

   211 {

   212     unsigned int ilen = aSrc.Length();

   214     if (0 == ilen)

   215     {

   216     	return EDescriptorNoData;

   217     }

   218     else if (!aDes)

   219     {

   220     	return EInvalidPointer;

   221     }

   222 	else if (n_size < (ilen+1))

   223 	{

   224 		n_size = ilen+1;

   225 		return EInvalidSize;

   226 	}

   228 	wmemcpy(aDes , (const wchar_t*)aSrc.Ptr(),ilen);

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

   231     return ESuccess;

   232 }

   234  /**

   235    * Converts a descriptor of type RBuf16 to WChar

   236    *

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

   238    * reference to the WChar stream where the result of conversion

   239    * is stored , n_size specifies the conversion length of the WChar

   240    * @return Status code (0 is ESuccess, -2 is EInvalidSize ,

   241    * -4 is EInvalidPointer , -5 is EDESCRIPTORNDATA)

   242    */

   244 EXPORT_C int Rbuf16ToWchar(TDes16& aSrc, wchar_t* aDes, int& n_size)

   245 {

   246     unsigned int ilen = aSrc.Length();

   248     if (0 == ilen)

   249     {

   250     	return EDescriptorNoData;

   251     }

   252     else if(!aDes)

   253     {

   254     	return EInvalidPointer;

   255     }

   256     else if (n_size < (ilen+1))

   257 	{

   258 		n_size = ilen + 1;

   259 		return EInvalidSize;

   260 	}

   262     wmemcpy (aDes,(const wchar_t *)aSrc.Ptr(), ilen);

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

   266 	return ESuccess;

   267 }

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