Symaptic: os/ossrv/utilitylibraries/libutils/src/chartodescriptor8.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 char * to Descriptor8 conversions

    15  *

    16 */

    20 #include "libutils.h"

    25 /**

    26    * Converts a character stream to TBuf8

    27    * @param aSrc is char* which is to be converted to TBuf8

    28    * @param aDes is the pointer to the descriptor of type TBuf8 which will hold

    29    * the result of conversion.aDes needs to be allocated with sufficient amount

    30    * of memory before being passed to function. This Descriptor should have

    31    * a allocation that is equal to or greater than char*

    32    *

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

    34    */

    36 EXPORT_C  int CharToTbuf8 (const char* aSrc, TDes8& aDes)

    37 {

    38 	if (!aSrc)

    39 	{

    40 	    return EInvalidPointer;

    41 	}

    42 	else

    43 	{

    44 	    if (strlen (aSrc) > aDes.MaxLength())

    45 	    {

    46 	    	return EInsufficientMemory;

    47 	    }

    48 	}

    50 	aDes.Copy ((const TUint8*)aSrc);

    52 	return ESuccess;

    53 }

    55  /**

    56    * Converts a character stream to HBufC8\\

    57    * @param aSrc is char* which is to be converted to HBufC8

    58    * @param aDes is the pointer to the descriptor of type HBufC8 which will hold

    59    * the result of conversion.aDes needs to be allocated with sufficient amount

    60    * of memory before being passed to function. This Descriptor should have

    61    * a allocation that is equal to or greater than char*

    62    *

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

    64    */

    66 EXPORT_C int CharToHbufc8(const char* aSrc, HBufC8* aDes)

    67 {

    68     unsigned int ilendes = 0;

    69 	if ( !aSrc || !aDes )

    70 	{

    71 		return EInvalidPointer;

    72 	}

    73 	else

    74 	{

    75 	    ilendes = aDes->Length();

    76 	    if(0 == ilendes)

    77 	    {

    78 	    	return EUseNewMaxL;

    79 	    }

    80 	    else if (strlen (aSrc) > ilendes)

    81 	    {

    82 	    	return EInsufficientMemory;

    83 	    }

    84 	}

    86 	*aDes = (const TUint8*)aSrc;

    87 	return ESuccess;

    89 }

    91  /**

    92    * Converts a character stream to Tptr8

    93    * @param aSrc is char* which is to be converted to TPtr8

    94    * @param aDes is the pointer to the descriptor of type TPtr8 which will hold

    95    * the result of conversion.aDes needs to be allocated with sufficient amount

    96    * of memory before being passed to function. This Descriptor should have

    97    * a allocation that is equal to or greater than char*

    98    *

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

   100    */

   102 EXPORT_C int CharpToTptr8( const char* aSrc, TPtr8& aDes )

   103 {

   104     unsigned int ilen = 0, ilendes = 0;

   105 	if (!aSrc)

   106 	{

   107 		return EInvalidPointer;

   108 	}

   110 	ilen = strlen(aSrc);

   111 	ilendes = aDes.MaxLength();

   113 	if (ilendes < ilen)

   114 	{

   115 		return EInsufficientMemory;

   116 	}

   118 	aDes.Set((TUint8 *)(aSrc), ilen, ilendes);

   120 	return ESuccess;

   121 }

   123  /**

   124    * Converts a character stream to TPtrc8

   125    * @param aSrc is char* which is to be converted to TPtrc8

   126    * @param aDes is the pointer to the descriptor of type TPtrc8 which will hold

   127    * the result of conversion.aDes needs to be allocated with sufficient amount

   128    * of memory before being passed to function. This Descriptor should have

   129    * a allocation that is equal to or greater than char*

   130    *

   131    * @return Status code (0 is ESuccess, -4 is EInvalidPointer)

   132    */

   134 EXPORT_C int CharpToTptrc8(const char* aSrc, TPtrC8& aDes)

   135 {

   136 	if ( !aSrc )

   137 	{

   138 		return EInvalidPointer;

   139 	}

   141 	aDes.Set((TUint8 *)(aSrc), strlen(aSrc));

   143 	return ESuccess;

   144 }

   146  /**

   147    * Converts a character stream to RBuf8

   148    * @param aSrc is char* which is to be converted to RBuf8

   149    * @param aDes is the pointer to the descriptor of type RBuf8 which will hold

   150    * the result of conversion.aDes needs to be allocated with sufficient amount

   151    * of memory before being passed to function. This Descriptor should have

   152    * a allocation that is equal to or greater than char*

   153    *

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

   155    */

   157 EXPORT_C int CharToRbuf8(const char* aSrc, RBuf8& aDes)

   158 {

   159   if ( !aSrc )

   160   {

   161     return EInvalidPointer;

   162   }

   164   aDes.Copy((const unsigned char *)aSrc, strlen(aSrc));

   166 	return ESuccess;

   167 }

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