// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32\include\e32cmn.inl

 // 

 //

 #ifndef __PLACEMENT_NEW_INLINE

 #define __PLACEMENT_NEW_INLINE

 // Global placement operator new

 inline TAny* operator new(TUint /*aSize*/, TAny* aBase) __NO_THROW

 	{return aBase;}

 // Global placement operator delete

 inline void operator delete(TAny* /*aPtr*/, TAny* /*aBase*/) __NO_THROW

 	{}

 #endif //__PLACEMENT_NEW_INLINE

 #ifndef __PLACEMENT_VEC_NEW_INLINE

 #define __PLACEMENT_VEC_NEW_INLINE

 // Global placement operator new[]

 inline TAny* operator new[](TUint /*aSize*/, TAny* aBase) __NO_THROW

 	{return aBase;}

 // Global placement operator delete[]

 inline void operator delete[](TAny* /*aPtr*/, TAny* /*aBase*/) __NO_THROW

 	{}

 #endif //__PLACEMENT_VEC_NEW_INLINE

 // class RAllocator

 inline RAllocator::RAllocator()

 	{

 	iAccessCount=1;

 	iHandleCount=0;

 	iHandles=0;

 	iFlags=0;

 	iCellCount=0;

 	iTotalAllocSize=0;

 	}

 inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum)

 	{__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);}

 // Class RHeap

 inline RHeap::RHeap()

 	{}

 /**

 @return The maximum length to which the heap can grow.

 @publishedAll

 @released

 */

 inline TInt RHeap::MaxLength() const

 	{return iMaxLength;}

 inline void RHeap::operator delete(TAny*, TAny*) 

 /**

 Called if constructor issued by operator new(TUint aSize, TAny* aBase) throws exception.

 This is dummy as corresponding new operator does not allocate memory.

 */

 	{}

 inline TUint8* RHeap::Base() const

 /**

 Gets a pointer to the start of the heap.

 Note that because of the small space overhead incurred by all allocated cells, 

 no cell will have the same address as that returned by this function.

 @return A pointer to the base of the heap.

 */

 	{return iBase;}

 inline TInt RHeap::Size() const

 /**

 Gets the current size of the heap.

 This is the total number of bytes committed by the host chunk. 

 It is the requested size rounded up by page size minus the size of RHeap object(116 bytes)

 minus the cell alignment overhead as shown:

 Size = (Rounded committed size - Size of RHeap - Cell Alignment Overhead).

 The cell alignment overhead varies between release builds and debug builds.

 Note that this value is always greater than the total space available across all allocated cells.

 @return The size of the heap.

 @see Rheap::Available( )

 */

 	{return iTop-iBase;}

 inline TInt RHeap::Align(TInt a) const

 /**

 @internalComponent

 */

 	{return _ALIGN_UP(a, iAlign);}

 inline const TAny* RHeap::Align(const TAny* a) const

 /**

 @internalComponent

 */

 	{return (const TAny*)_ALIGN_UP((TLinAddr)a, iAlign);}

 inline TBool RHeap::IsLastCell(const SCell* aCell) const

 /**

 @internalComponent

 */

 	{return (((TUint8*)aCell) + aCell->len) == iTop;}

 #ifndef __KERNEL_MODE__

 inline void RHeap::Lock() const

 /**

 @internalComponent

 */

 	{((RFastLock&)iLock).Wait();}

 inline void RHeap::Unlock() const

 /**

 @internalComponent

 */

 	{((RFastLock&)iLock).Signal();}

 inline TInt RHeap::ChunkHandle() const

 /**

 @internalComponent

 */

 	{

 	return iChunkHandle;

 	}

 #endif

 // Class TRefByValue

 template <class T>

 inline TRefByValue<T>::TRefByValue(T &aRef)

 	: iRef(aRef)

 /**

 Constructs this value reference for the specified referenced object.

 @param aRef The referenced object.

 */

 	{}

 template <class T>

 inline TRefByValue<T>::operator T &()

 /**

 Gets a reference to the object encapsulated inside this value reference.

 */

 	{return(iRef);}

 /**

 Creates the logical channel.

 @param aDevice    The name of the logical device for which the channel

                   is to be constructed. This is the name by which

 				  the LDD factory object, i.e. the instance of

 				  the DLogicalDevice derived class, is known.

 @param aVer       The required version of the logical device. The driver

                   normally checks this against the version of the logical

 				  channel, returning KErrNotSupported if the logical channel

 				  is not compatible.

 @param aUnit      A unit of the device. This argument only has meaning if

                   the flag KDeviceAllowUnit is set in the iParseMask data

 				  member of the LDD factory object.

 @param aDriver    A pointer to a descriptor containing the name of

                   a physical device. This is the name by which the PDD

 				  factory object, i.e. the instance of the DPhysicalDevice

 				  derived class, is known.

                   This is NULL, if no explicit name is to be supplied, or

 				  the logical device does not require an accompanying physical

 				  device.

 @param aInfo      A pointer to an explicit 8-bit descriptor containing extra

                   information for the physical device. This argument only has

 				  meaning if the KDeviceAllowInfo flag is set in the iParseMask

 				  data member of the LDD factory object.

 @param aType      An enumeration whose enumerators define the ownership of

                   this handle. If not explicitly specified, EOwnerProcess is

 				  taken as default.

 @param aTransferable If false, the channel is created as an object which is

                      local/private to the current process.

                      If true, the channel is an object which may be shared with

                      other processes using the IPC mechanisms for handle passing.

 @return  KErrNone, if successful; otherwise one of the other system wide

          error codes.

 */

 inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable)

 	{ return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); }

 // Class TChar

 inline TChar::TChar()

 /**

 Default constructor.

 Constructs this character object with an undefined value.

 */

 	{}

 inline TChar::TChar(TUint aChar)

 	: iChar(aChar)

 /**

 Constructs this character object and initialises it with the specified value.

 @param aChar The initialisation value.

 */

 	{}

 inline TChar& TChar::operator-=(TUint aChar)

 /**

 Subtracts an unsigned integer value from this character object.

 This character object is changed by the operation.

 @param aChar The value to be subtracted.

 @return A reference to this character object.

 */

 	{iChar-=aChar;return(*this);}

 inline TChar& TChar::operator+=(TUint aChar)

 /**

 Adds an unsigned integer value to this character object.

 This character object is changed by the operation.

 @param aChar The value to be added.

 @return A reference to this character object.

 */

 	{iChar+=aChar;return(*this);}

 inline TChar TChar::operator-(TUint aChar)

 /**

 Gets the result of subtracting an unsigned integer value from this character 

 object.

 This character object is not changed.

 @param aChar The value to be subtracted.

 @return A character object whose value is the result of the subtraction

         operation.

 */

 	{return(iChar-aChar);}

 inline TChar TChar::operator+(TUint aChar)

 /** 

 Gets the result of adding an unsigned integer value to this character object. 

 This character object is not changed.

 @param aChar The value to be added.

 @return A character object whose value is the result of the addition operation.

 */

 	{return(iChar+aChar);}

 inline TChar::operator TUint() const

 /**

 Gets the value of the character as an unsigned integer. 

 The operator casts a TChar to a TUint, returning the TUint value wrapped by

 this character object.

 */

 	{return(iChar);}

 // Class TDesC8

 inline TBool TDesC8::operator<(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is less than the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data.

 @return True if greater than or equal, false otherwise.

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)<0);}

 inline TBool TDesC8::operator<=(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is less than or equal to the

 specified descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if less than or equal, false otherwise. 

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)<=0);}

 inline TBool TDesC8::operator>(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is greater than the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if greater than, false otherwise. 

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)>0);}

 inline TBool TDesC8::operator>=(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is greater than or equal to the

 specified descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if greater than, false otherwise.

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)>=0);}

 inline TBool TDesC8::operator==(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is equal to the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if equal, false otherwise. 

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)==0);}

 inline TBool TDesC8::operator!=(const TDesC8 &aDes) const

 /**

 Determines whether this descriptor's data is not equal to the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 8-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if not equal, false otherwise. 

 @see TDesC8::Compare

 */

 	{return(Compare(aDes)!=0);}

 inline const TUint8 &TDesC8::operator[](TInt anIndex) const

 /**

 Gets a reference to a single data item within this descriptor's data.

 @param anIndex The position of the individual data item within the descriptor's 

                data. This is an offset value; a zero value refers to the

                leftmost data position. 

 @return A reference to the data item.

 @panic USER 21, if anIndex is negative or greater than or equal to the current

                 length of the descriptor.

 */

 	{return(AtC(anIndex));}

 inline TInt TDesC8::Length() const

 /**

 Gets the length of the data.

 This is the number of 8-bit values or data items represented by the descriptor.

 @return The length of the data represented by the descriptor.

 */

 	{return(iLength&KMaskDesLength8);}

 inline TInt TDesC8::Size() const

 /**

 Gets the size of the data.

 This is the number of bytes occupied by the data represented by the descriptor.

 @return The size of the data represented by the descriptor.

 */

 	{return(Length());}

 inline void TDesC8::DoSetLength(TInt aLength)

 	{iLength=(iLength&(~KMaskDesLength8))|aLength;}

 // Class TPtrC8

 inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength)

 /**

 Sets the 8-bit non-modifiable pointer descriptor to point to the specified 

 location in memory, whether in RAM or ROM.

 The length of the descriptor is set to the specified length.

 @param aBuf    A pointer to the location that the descriptor is to represent.

 @param aLength The length of the descriptor. This value must be non-negative.

 @panic USER 29, if aLength is negative.

 */

 	{new(this) TPtrC8(aBuf,aLength);}

 inline void TPtrC8::Set(const TDesC8 &aDes)

 /**

 Sets the 8-bit non-modifiable pointer descriptor from the specified descriptor.

 It is set to point to the same data and is given the same length.

 @param aDes A reference to an 8-bit non-modifiable descriptor.

 */

 	{new(this) TPtrC8(aDes);}

 inline void TPtrC8::Set(const TPtrC8& aPtr)

 /**

 Sets the 8-bit non-modifiable pointer descriptor from the specified

 non-modifiable pointer descriptor.

 It is set to point to the same data and is given the same length.

 @param aPtr A reference to an 8-bit non-modifiable pointer descriptor.

 */

 	{new(this) TPtrC8(aPtr);}

 // class TBufCBase8

 inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)

 	{return TPtr8(*this,aMaxLength);}

 // Template class TBufC8

 template <TInt S>

 inline TBufC8<S>::TBufC8()

 	: TBufCBase8()

 /** 

 Constructs an empty 8-bit non-modifiable buffer descriptor.

 It contains no data.

 The integer template parameter determines the size of the data area which 

 is created as part of the buffer descriptor object.

 Data can, subsequently, be assigned into this buffer descriptor using the 

 assignment operators.

 @see TBufC8::operator=

 */

 	{}

 template <TInt S>

 inline TBufC8<S>::TBufC8(const TUint8 *aString)

 	: TBufCBase8(aString,S)

 /**

 Constructs the 8-bit non-modifiable buffer descriptor from a zero terminated 

 string.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 The string, excluding the zero terminator, is copied into this buffer descriptor's 

 data area. The length of this buffer descriptor is set to the length of the 

 string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 20, if the length of the string, excluding the zero terminator, is

                 greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBufC8<S>::TBufC8(const TDesC8 &aDes)

 	: TBufCBase8(aDes,S)

 /**

 Constructs the 8-bit non-modifiable buffer descriptor from any

 existing descriptor.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 Data is copied from the source descriptor into this buffer descriptor and 

 the length of this buffer descriptor is set to the length of the

 source descriptor.

 @param aDes The source 8-bit non-modifiable descriptor.

 @panic USER 20, if the length of the source descriptor is

                 greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBufC8<S> &TBufC8<S>::operator=(const TUint8 *aString)

 /**

 Copies data into this descriptor, replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string. 

 @return A reference to this descriptor.

 @panic USER 23, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aString,S);return(*this);}

 template <TInt S>

 inline TBufC8<S> &TBufC8<S>::operator=(const TDesC8 &aDes)

 /**

 Copies data into this descriptor, replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit non-modifiable descriptor. 

 @return A reference to this descriptor.

 @panic USER 23, if the length of the descriptor aDes is

                 greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aDes,S);return(*this);}

 template <TInt S>

 inline TPtr8 TBufC8<S>::Des()

 /**

 Creates and returns an 8-bit modifiable pointer descriptor for the data

 represented by this 8-bit non-modifiable buffer descriptor.

 The content of a non-modifiable buffer descriptor normally cannot be altered, 

 other than by complete replacement of the data. Creating a modifiable pointer 

 descriptor provides a way of changing the data.

 The modifiable pointer descriptor is set to point to this non-modifiable buffer 

 descriptor's data.

 The length of the modifiable pointer descriptor is set to the length of this 

 non-modifiable buffer descriptor.

 The maximum length of the modifiable pointer descriptor is set to the value 

 of the integer template parameter.

 When data is modified through this new pointer descriptor, the lengths of 

 both it and this constant buffer descriptor are changed.

 @return An 8-bit modifiable pointer descriptor representing the data in this 

         8-bit non-modifiable buffer descriptor.

 */

 	{return DoDes(S);}

 #ifndef __KERNEL_MODE__

 // Class HBufC8

 inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb)

 /**

 Copies data into this 8-bit heap descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 Note that the maximum length of this (target) descriptor is the length

 of the descriptor buffer in the allocated host heap cell; this may be greater

 than the maximum length specified when this descriptor was created or

 last re-allocated.

 @param aLcb The source 8-bit heap descriptor.

 @return A reference to this 8-bit heap descriptor.

 @panic USER 23, if the length of the descriptor aLcb is greater than the

                 maximum length of this (target) descriptor

 */

 	{return *this=static_cast<const TDesC8&>(aLcb);}

 // Class RBuf8

 inline RBuf8& RBuf8::operator=(const TUint8* aString)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

     {Copy(aString);return(*this);}

 inline RBuf8& RBuf8::operator=(const TDesC8& aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit non-modifiable descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline RBuf8& RBuf8::operator=(const RBuf8& aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 8-bit buffer descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 /**

 Creates an 8-bit resizable buffer descriptor that has been initialised with

 data from the specified read stream; leaves on failure.

 Data is assigned to the new descriptor from the specified stream.

 This variant assumes that the stream contains the length of the data followed

 by the data itself.

 The function is implemented by calling the HBufC8::NewL(RReadStream&,TInt)

 variant and then assigning the resulting heap descriptor using

 the RBuf8::Assign(HBufC8*) variant. The comments that describe

 the HBufC8::NewL() variant	also apply to this RBuf8::CreateL() function.

 The function may leave with one of the system-wide error codes,	specifically 

 KErrOverflow, if the length of the data as read from the stream is greater than

 the upper limit as specified by the aMaxLength parameter.

 @param aStream    The stream from which the data length and the data to be

                   assigned to the new descriptor, are taken.

 @param aMaxLength The upper limit on the length of data that the descriptor is

                   to represent. The value of this parameter must be non-negative

                   otherwise the	underlying function will panic.

 */

 inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength)

 	{

 	Assign(HBufC8::NewL(aStream,aMaxLength));

 	}

 #endif

 // Class TDes8

 inline TDes8 &TDes8::operator=(const TUint8 *aString)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this, the target descriptor.

 @panic USER 23, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

     {Copy(aString);return(*this);}

 inline TDes8 &TDes8::operator=(const TDesC8 &aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit non-modifiable descriptor. 

 @return A reference to this, the target descriptor.

 @panic USER 23, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline TDes8 &TDes8::operator=(const TDes8 &aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit modifiable descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 23, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline TDes8 &TDes8::operator+=(const TDesC8 &aDes)

 /**

 Appends data onto the end of this descriptor's data and returns a reference 

 to this descriptor.

 The length of this descriptor is incremented to reflect the new content.

 @param aDes An-8 bit non-modifiable descriptor whose data is to be appended.

 @return A reference to this descriptor.

 @panic USER 23, if the resulting length of this descriptor is greater than its

                 maximum length.  

 */

 	{Append(aDes);return(*this);}

 inline const TUint8 &TDes8::operator[](TInt anIndex) const

 /**

 Gets a const reference to a single data item within this descriptor's data.

 @param anIndex The position of the data item within this descriptor's data.

                This is an offset value; a zero value refers to the leftmost

 			   data position.

 @return A const reference to the data item at the specified position. 

 @panic USER 21, if anIndex is negative or is greater than or equal to the

                 current length of this descriptor.

 */

 	{return(AtC(anIndex));}

 inline TUint8 &TDes8::operator[](TInt anIndex)

 /**

 Gets a non-const reference to a single data item within this descriptor's 

 data.

 @param anIndex The position of the data item within this descriptor's data.

                This is an offset value; a zero value refers to the leftmost

 			   data position.

 @return A non-const reference to the data item at the specified position.

 @panic USER 21, if anIndex is negative or is greater than or equal to the

                 current length of this descriptor.

 */

 	{return((TUint8 &)AtC(anIndex));}

 inline TInt TDes8::MaxLength() const

 /**

 Gets the maximum length of the descriptor.

 This is the upper limit for the number of 8-bit values or data items that

 the descriptor can represent.

 @return The maximum length of data that the descriptor can represent.

 */

 	{return(iMaxLength);}

 inline TInt TDes8::MaxSize() const

 /**

 Gets the maximum size of the descriptor.

 This is the upper limit for the number of bytes which the data represented by

 the descriptor can occupy.

 @return The maximum size of the descriptor data.

 */

 	{return(iMaxLength);}

 inline TUint8 * TDes8::WPtr() const

 	{return((TUint8 *)Ptr());}

 // Class TPtr8

 inline TPtr8 &TPtr8::operator=(const TUint8 *aString)

 /**

 Copies data into this 8-bit modifiable pointer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this 8-bit modifiable pointer descriptor.

 @panic USER 23, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this descriptor.

 */

 	{Copy(aString);return(*this);}

 inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes)

 /**

 Copies data into this 8-bit modifiable pointer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit modifiable pointer descriptor whose data is to be copied 

             into this descriptor.

 @return A reference to this 8-bit modifiable pointer descriptor.

 @panic USER 23, if the length of aDes is greater than the maximum 

                 length of this descriptor.

 */

 	{Copy(aDes);return(*this);}

 inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes)

 /**

 Copies data into this 8-bit modifiable pointer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8-bit modifiable pointer descriptor whose data is to be copied

             into this descriptor.

 @return A reference to this 8-bit modifiable pointer descriptor.

 @panic USER 23, if the length of aDes is greater than the maximum 

                 length of this descriptor.

 */

 	{Copy(aDes);return(*this);}

 inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength)

 /**

 Sets the 8-bit modifiable pointer descriptor to point to the specified location

 in memory, whether in RAM or ROM.

 The length of the descriptor and its maximum length are set to the specified

 values.

 @param aBuf       A pointer to the location that the descriptor is to represent.

 @param aLength    The length of the descriptor.

 @param aMaxLength The maximum length of the descriptor.

 @panic USER 20, if aLength is negative or is greater than the maximum length of

                 this descriptor.

 @panic USER 30, if aMaxLength is negative.

 */

 	{new(this) TPtr8(aBuf,aLength,aMaxLength);}

 inline void TPtr8::Set(const TPtr8 &aPtr)

 /**

 Sets the 8-bit modifiable pointer descriptor from an existing 8-bit modifiable

 pointer descriptor.

 It is set to point to the same data, is given the same length and the same

 maximum length as the source pointer descriptor.

 @param aPtr The source 8-bit modifiable pointer descriptor.

 */

 	{new(this) TPtr8(aPtr);}

 // Template class TBuf8

 template <TInt S>

 inline TBuf8<S>::TBuf8()

 	: TBufBase8(S)

 /**

 Constructs an empty 8-bit modifiable buffer descriptor.

 It contains no data.

 The integer template parameter determines the size of the data area that is created 

 as part of the object, and defines the descriptor's maximum length.

 */

 	{}

 template <TInt S>

 inline TBuf8<S>::TBuf8(TInt aLength)

 	: TBufBase8(aLength,S)

 /**

 Constructs an empty 8-bit modifiable buffer descriptor and sets the its length 

 to the specified value.

 No data is assigned to the descriptor.

 The integer template parameter determines the size of the data area that is created 

 as part of the object, and defines the descriptor's maximum length.

 @param aLength The length of this modifiable buffer descriptor.

 @panic USER 20, if aLength is negative or is greater than the 

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf8<S>::TBuf8(const TUint8 *aString)

 	: TBufBase8(aString,S)

 /**

 Constructs the 8-bit modifiable buffer descriptor from a

 zero terminated string.

 The integer template parameter determines the size of the data area that

 is created as part of the object, and defines the descriptor's maximum length.

 The string, excluding the zero terminator, is copied into this buffer

 descriptor's data area. The length of this buffer descriptor is set to the

 length of the string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf8<S>::TBuf8(const TDesC8 &aDes)

 	: TBufBase8(aDes,S)

 /**

 Constructs the 8-bit modifiable buffer descriptor from any existing

 8-bit descriptor.

 The integer template parameter determines the size of the data area created 

 as part of this object and defines the descriptor's maximum length.

 Data is copied from the source descriptor into this modifiable buffer

 descriptor and the length of this modifiable buffer descriptor is set to

 the length of the source descriptor.

 @param aDes The source 8-bit non-modifiable descriptor.

 @panic USER 23, if the length of the source descriptor is greater than the

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf8<S> &TBuf8<S>::operator=(const TUint8 *aString)

 /**

 Copies data into this 8-bit modifiable buffer descriptor, replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aString);return(*this);}

 template <TInt S>

 inline TBuf8<S> &TBuf8<S>::operator=(const TDesC8 &aDes)

 /**

 Copies data into this 8-bit modifiable buffer descriptor, replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8 bit non-modifiable descriptor.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 @panic USER 23, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

 	{Copy(aDes);return(*this);}

 template <TInt S>

 inline TBuf8<S>& TBuf8<S>::operator=(const TBuf8<S>& aBuf)

 /**

 Copies data into this 8-bit modifiable buffer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aBuf The source 8-bit modifiable buffer descriptor with the same

             template value.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 */

 	{Copy(aBuf);return *this;}

 // Template class TAlignedBuf8

 template <TInt S>

 inline TAlignedBuf8<S>::TAlignedBuf8()

 	: TBufBase8(S)

 /**

 Constructs an empty 8-bit modifiable buffer descriptor.

 It contains no data.

 The integer template parameter determines the size of the data area that is created 

 as part of the object, and defines the descriptor's maximum length.

 */

 	{}

 template <TInt S>

 inline TAlignedBuf8<S>::TAlignedBuf8(TInt aLength)

 	: TBufBase8(aLength,S)

 /**

 Constructs an empty 8-bit modifiable buffer descriptor and sets the its length 

 to the specified value.

 No data is assigned to the descriptor.

 The integer template parameter determines the size of the data area that is created 

 as part of the object, and defines the descriptor's maximum length.

 @param aLength The length of this modifiable buffer descriptor.

 @panic USER 20, if aLength is negative or is greater than the 

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TAlignedBuf8<S>::TAlignedBuf8(const TUint8 *aString)

 	: TBufBase8(aString,S)

 /**

 Constructs the 8-bit modifiable buffer descriptor from a

 zero terminated string.

 The integer template parameter determines the size of the data area that

 is created as part of the object, and defines the descriptor's maximum length.

 The string, excluding the zero terminator, is copied into this buffer

 descriptor's data area. The length of this buffer descriptor is set to the

 length of the string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TAlignedBuf8<S>::TAlignedBuf8(const TDesC8 &aDes)

 	: TBufBase8(aDes,S)

 /**

 Constructs the 8-bit modifiable buffer descriptor from any existing

 8-bit descriptor.

 The integer template parameter determines the size of the data area created 

 as part of this object and defines the descriptor's maximum length.

 Data is copied from the source descriptor into this modifiable buffer

 descriptor and the length of this modifiable buffer descriptor is set to

 the length of the source descriptor.

 @param aDes The source 8-bit non-modifiable descriptor.

 @panic USER 23, if the length of the source descriptor is greater than the

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TUint8 *aString)

 /**

 Copies data into this 8-bit modifiable buffer descriptor, replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aString);return(*this);}

 template <TInt S>

 inline TAlignedBuf8<S> &TAlignedBuf8<S>::operator=(const TDesC8 &aDes)

 /**

 Copies data into this 8-bit modifiable buffer descriptor, replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes An 8 bit non-modifiable descriptor.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 @panic USER 23, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

 	{Copy(aDes);return(*this);}

 template <TInt S>

 inline TAlignedBuf8<S>& TAlignedBuf8<S>::operator=(const TAlignedBuf8<S>& aBuf)

 /**

 Copies data into this 8-bit modifiable buffer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aBuf The source 8-bit modifiable buffer descriptor with the same

             template value.

 @return A reference to this 8-bit modifiable buffer descriptor. 

 */

 	{Copy(aBuf);return *this;}

 // Template class TLitC8

 template <TInt S>

 inline const TDesC8* TLitC8<S>::operator&() const

 /**

 Returns a const TDesC8 type pointer.

 @return A descriptor type pointer to this literal. 

 */

 	{return REINTERPRET_CAST(const TDesC8*,this);}

 template <TInt S>

 inline const TDesC8& TLitC8<S>::operator()() const

 /**

 Returns a const TDesC8 type reference.

 @return A descriptor type reference to this literal 

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC8<S>::operator const TDesC8&() const

 /**

 Invoked by the compiler when a TLitC8<TInt> type is passed to a function

 which is prototyped to take a const TDesC8& type.

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC8<S>::operator const __TRefDesC8() const

 /**

 Invoked by the compiler when a TLitC8<TInt> type is passed to a function

 which is prototyped to take a const TRefByValue<const TDesC8> type.

 @see __TRefDesC8

 */

 	{return *operator&();}

 #ifndef __KERNEL_MODE__

 // Class TDesC16

 inline TBool TDesC16::operator<(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is less than the specified descriptor's 

 data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non-modifable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if less than, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)<0);}

 inline TBool TDesC16::operator<=(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is less than or equal

 to the specified descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non- modifiable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if less than or equal, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)<=0);}

 inline TBool TDesC16::operator>(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is greater than the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non-modifiable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if greater than, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)>0);}

 inline TBool TDesC16::operator>=(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is greater than or equal to the

 specified descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non-modifiable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if greater than or equal, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)>=0);}

 inline TBool TDesC16::operator==(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is equal to the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non-modifiable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if equal, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)==0);}

 inline TBool TDesC16::operator!=(const TDesC16 &aDes) const

 /**

 Determines whether this descriptor's data is not equal to the specified

 descriptor's data.

 The comparison is implemented using the Compare() member function.

 @param aDes The 16-bit non-modifiable descriptor whose data is to be compared 

             with this descriptor's data. 

 @return True if not equal, false otherwise. 

 @see TDesC16::Compare

 */

 	{return(Compare(aDes)!=0);}

 inline const TUint16 &TDesC16::operator[](TInt anIndex) const

 /**

 Gets a reference to a single data item within this descriptor's data.

 @param anIndex The position of the individual data item within the descriptor's 

                data. This is an offset value; a zero value refers to the

 			   leftmost data position. 

 @return A reference to the data item.

 @panic USER 9, if anIndex is negative or greater than or equal to the current

                length of the descriptor.

 */

 	{return(AtC(anIndex));}

 inline TInt TDesC16::Length() const

 /**

 Gets the length of the data.

 This is the number of 16-bit values or data items represented by the descriptor.

 @return The length of the data represented by the descriptor.

 */

 	{return(iLength&KMaskDesLength16);}

 inline TInt TDesC16::Size() const

 /**

 Gets the size of the data.

 This is the number of bytes occupied by the data represented by the descriptor.

 @return The size of the data represented by the descriptor. This is always 

         twice the length.

  */

 	{return(Length()<<1);}

 inline void TDesC16::DoSetLength(TInt aLength)

 	{iLength=(iLength&(~KMaskDesLength16))|aLength;}

 // Class TPtrC16

 inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength)

 /**

 Sets the 16-bit non-modifiable pointer descriptor to point to the specified 

 location in memory, whether in RAM or ROM.

 The length of the descriptor is set to the specified length.

 @param aBuf    A pointer to the location that the descriptor is to represent.

 @param aLength The length of the descriptor. This value must be non-negative 

 @panic USER 17, if aLength is negative.

 */

 	{new(this) TPtrC16(aBuf,aLength);}

 inline void TPtrC16::Set(const TDesC16 &aDes)

 /**

 Sets the 16-bit non-modifiable pointer descriptor from the specified descriptor.

 It is set to point to the same data and is given the same length.

 @param aDes A reference to a 16-bit non-modifiable descriptor

 */

 	{new(this) TPtrC16(aDes);}

 inline void TPtrC16::Set(const TPtrC16& aPtr)

 	{new(this) TPtrC16(aPtr);}

 // class TBufCBase16

 inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength)

 	{return TPtr16(*this,aMaxLength);}

 // Template class TBufC16

 template <TInt S>

 inline TBufC16<S>::TBufC16()

 	: TBufCBase16()

 /**

 Constructs an empty 16-bit non-modifiable buffer descriptor. 

 It contains no data.

 The integer template parameter determines the size of the data area which 

 is created as part of the buffer descriptor object.

 Data can, subsequently, be assigned into this buffer descriptor using the 

 assignment operators.

 @see TBufC16::operator=

 */

 	{}

 template <TInt S>

 inline TBufC16<S>::TBufC16(const TUint16 *aString)

 	: TBufCBase16(aString,S)

 /** 

 Constructs the 16-bit non-modifiable buffer descriptor from a zero terminated

 string.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 The string, excluding the zero terminator, is copied into this buffer descriptor's 

 data area. The length of this buffer descriptor is set to the length of the 

 string, excluding the zero terminator.

 @panic USER 8, if the length of the string, excluding the zero terminator, is

                greater than the value of the integer template parameter.

 @param aString A pointer to a zero terminated string.

 */

 	{}

 template <TInt S>

 inline TBufC16<S>::TBufC16(const TDesC16 &aDes)

 	: TBufCBase16(aDes,S)

 /**

 Constructs the 16-bit non-modifiable buffer descriptor from any

 existing descriptor.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 Data is copied from the source descriptor into this buffer descriptor and 

 the length of this buffer descriptor is set to the length of the

 source descriptor.

 @param aDes The source 16-bit non-modifiable descriptor.

 @panic USER 8, if the length of the source descriptor is

                greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBufC16<S> &TBufC16<S>::operator=(const TUint16 *aString)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aString,S);return(*this);}

 template <TInt S>

 inline TBufC16<S> &TBufC16<S>::operator=(const TDesC16 &aDes)

 /**

 Copies data into this descriptor, replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit non-modifiable descriptor.

 @panic USER 11, if the length of the descriptor aDes is

                 greater than the maximum length of this (target) descriptor.

 @return A reference to this descriptor.

 */

 	{Copy(aDes,S);return(*this);}

 template <TInt S>

 inline TPtr16 TBufC16<S>::Des()

 /**

 Creates and returns a 16-bit modifiable pointer descriptor for the data

 represented by this 16-bit non-modifiable buffer descriptor.

 The content of a non-modifiable buffer descriptor normally cannot be altered, 

 other than by complete replacement of the data. Creating a modifiable pointer 

 descriptor provides a way of changing the data.

 The modifiable pointer descriptor is set to point to this non-modifiable buffer 

 descriptor's data.

 The length of the modifiable pointer descriptor is set to the length of this 

 non-modifiable buffer descriptor.

 The maximum length of the modifiable pointer descriptor is set to the value 

 of the integer template parameter.

 When data is modified through this new pointer descriptor, the lengths of 

 both it and this constant buffer descriptor are changed.

 @return A 16-bit modifiable pointer descriptor representing the data in this 

         16-bit non-modifiable buffer descriptor.

 */

 	{return(DoDes(S));}

 #ifndef __KERNEL_MODE__

 // Class HBufC16

 inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb)

 /**

 Copies data into this 16-bit heap descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 Note that the maximum length of this (target) descriptor is the length

 of the descriptor buffer in the allocated host heap cell; this may be greater

 than the maximum length specified when this descriptor was created or

 last re-allocated.

 @param aLcb The source 16-bit heap descriptor.

 @return A reference to this 16-bit heap descriptor.

 @panic USER 11, if the length of the descriptor aLcb is greater than the

                 maximum length of this (target) descriptor

 */

 	{return *this=static_cast<const TDesC16&>(aLcb);}

 #endif

 // Class TDes16

 inline TDes16 &TDes16::operator=(const TUint16 *aString)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

     {Copy(aString);return(*this);}

 inline TDes16 &TDes16::operator=(const TDesC16 &aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit non-modifiable descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline TDes16 &TDes16::operator=(const TDes16 &aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit modifiable descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline TDes16 &TDes16::operator+=(const TDesC16 &aDes)

 /** 

 Appends data onto the end of this descriptor's data and returns a reference 

 to this descriptor.

 The length of this descriptor is incremented to reflect the new content.

 @param aDes A 16-bit non-modifiable descriptor whose data is to be appended. 

 @return A reference to this descriptor.

 @panic USER 11, if the resulting length of this descriptor is greater than its

                 maximum length.  

 */

 	{Append(aDes);return(*this);}

 inline const TUint16 &TDes16::operator[](TInt anIndex) const

 /**

 Gets a const reference to a single data item within this descriptor's data.

 @param anIndex The position the data item within this descriptor's data. This 

 is an offset value; a zero value refers to the leftmost data position.

 @return A const reference to the data item at the specified position.

 @panic USER 9, if anIndex is negative or is greater than or equal to the

                 current length of this descriptor.

 */

 	{return(AtC(anIndex));}

 inline TUint16 &TDes16::operator[](TInt anIndex)

 /** 

 Gets a non-const reference to a single data item within this descriptor's 

 data.

 @param anIndex The position of the data item within this descriptor's data.

                This is an offset value; a zero value refers to the leftmost

 			   data position. 

 @return A non-const reference to the data item at the specified position.

 @panic USER 9, if anIndex is negative or is greater than or equal to the

                 current length of this descriptor.

 */

 	{return((TUint16 &)AtC(anIndex));}

 inline TInt TDes16::MaxLength() const

 /**

 Gets the maximum length of the descriptor.

 This is the upper limit for the number of 16-bit values or data items that

 the descriptor can represent.

 @return The maximum length of data that the descriptor can represent.

 */

 	{return(iMaxLength);}

 inline TInt TDes16::MaxSize() const

 /**

 Gets the maximum size of the descriptor.

 This is the upper limit for the number of bytes which the data represented by

 the descriptor can occupy.

 @return The maximum size of the descriptor data.

 */

 	{return(iMaxLength<<1);}

 inline TUint16 * TDes16::WPtr() const

 	{return((TUint16 *)Ptr());}

 // Class TPtr16

 inline TPtr16 &TPtr16::operator=(const TUint16 *aString)

 /**

 Copies data into this 16-bit modifiable pointer descriptor replacing

 any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this 16-bit modifiable pointer descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this descriptor.

 */

 	{Copy(aString);return(*this);}

 inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes)

 /**

 Copies data into this 16-bit modifiable pointer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit non-modifiable descriptor whose data is to be copied 

             into this descriptor.

 @return A reference to this 16-bit modifiable pointer descriptor.

 @panic USER 11, if the length of aDes is greater than the maximum 

                 length of this descriptor.

 */

 	{Copy(aDes);return(*this);}

 inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes)

 /**

 Copies data into this 16-bit modifiable pointer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit modifiable pointer descriptor whose data is to be copied 

             into this descriptor.

 @return A reference to this 16-bit modifiable pointer descriptor.

 @panic USER 11, if the length of aDes is greater than the maximum 

                 length of this descriptor.

 */

 	{Copy(aDes);return(*this);}

 inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength)

 /**

 Sets the 16-bit modifiable pointer descriptor to point to the specified location 

 in memory, whether in RAM or ROM.

 The length of the descriptor and its maximum length are set to the specified

 values.

 @param aBuf       A pointer to the location that the descriptor is to represent.

 @param aLength    The length of the descriptor.

 @param aMaxLength The maximum length of the descriptor.

 @panic USER 8,  if aLength is negative or is greater than the maximum length of

                 this descriptor.

 @panic USER 18, if aMaxLength is negative.

 */

 	{new(this) TPtr16(aBuf,aLength,aMaxLength);}

 inline void TPtr16::Set(const TPtr16 &aPtr)

 /**

 Sets the 16-bit modifiable pointer descriptor from an existing

 16-bit modifiable pointer descriptor.

 It is set to point to the same data, is given the same length and the same

 maximum length as the source pointer descriptor.

 @param aPtr The source 16-bit modifiable pointer descriptor.

 */

 	{new(this) TPtr16(aPtr);}

 // Template class TBuf16

 template <TInt S>

 inline TBuf16<S>::TBuf16()

 	: TBufBase16(S)

 /**

 Constructs an empty 16-bit modifiable buffer descriptor.

 It contains no data.

 The integer template parameter determines the size of the data area created 

 as part of the object and defines the descriptor's maximum length.

 */

 	{}

 template <TInt S>

 inline TBuf16<S>::TBuf16(TInt aLength)

 	: TBufBase16(aLength,S)

 /**

 Constructs an empty 16-bit modifiable buffer descriptor and sets the its length 

 to the specified value.

 No data is assigned to the descriptor.

 The integer template parameter defines the size of the data area created as 

 part of the object and defines the descriptor's maximum length.

 @param aLength The length of this modifiable buffer descriptor.

 @panic USER 8, if aLength is negative or is greater than the 

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf16<S>::TBuf16(const TUint16 *aString)

 	: TBufBase16(aString,S)

 /**

 Constructs the 16-bit modifiable buffer descriptor from

 a zero terminated string.

 The integer template parameter determines the size of the data area that is

 created as part of this object, and defines the descriptor's maximum length.

 The string, excluding the zero terminator, is copied into this buffer

 descriptor's data area. The length of this buffer descriptor is set to the

 length of the string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 11, if the length of the string, excluding the zero terminator,

                 is greater than the value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf16<S>::TBuf16(const TDesC16 &aDes)

 	: TBufBase16(aDes,S)

 /**

 Constructs the 16-bit modifiable buffer descriptor from any existing

 16-bit descriptor.

 The integer template parameter determines the size of the data area created 

 as part of this object and defines the descriptor's maximum length.

 Data is copied from the source descriptor into this modifiable buffer descriptor 

 and the length of this modifiable buffer descriptor is set to the length of 

 the source descriptor.

 @param aDes The source 16-bit non-modifiable descriptor.

 @panic USER 11, if the length of the source descriptor is greater than the

                 value of the integer template parameter.

 */

 	{}

 template <TInt S>

 inline TBuf16<S> &TBuf16<S>::operator=(const TUint16 *aString)

 /**

 Copies data into this 16-bit modifiable buffer descriptor, replacing any

 existing data. 

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator,

                 is greater than the maximum length of this (target) descriptor.

 */

 	{Copy(aString);return(*this);}

 template <TInt S>

 inline TBuf16<S> &TBuf16<S>::operator=(const TDesC16 &aDes)

 /**

 Copies data into this 16-bit modifiable descriptor, replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit non-modifiable descriptor.

 @return A reference to this descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

 	{Copy(aDes);return(*this);}

 template <TInt S>

 inline TBuf16<S>& TBuf16<S>::operator=(const TBuf16<S>& aBuf)

 /**

 Copies data into this 16-bit modifiable buffer descriptor replacing any

 existing data.

 The length of this descriptor is set to reflect the new data.

 @param aBuf The source 16-bit modifiable buffer descriptor with the same

             template value.

 @return A reference to this 16-bit modifiable buffer descriptor. 

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

 	{Copy(aBuf);return *this;}

 // Class RBuf16

 inline RBuf16& RBuf16::operator=(const TUint16* aString)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator, is

                 greater than the maximum length of this (target) descriptor.

 */

     {Copy(aString);return(*this);}

 inline RBuf16& RBuf16::operator=(const TDesC16& aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit non-modifiable descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 inline RBuf16& RBuf16::operator=(const RBuf16& aDes)

 /**

 Copies data into this descriptor replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A 16-bit buffer descriptor.

 @return A reference to this, the target descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor.

 */

     {Copy(aDes);return(*this);}

 /**

 Creates a 16-bit resizable buffer descriptor that has been initialised with

 data from the specified read stream; leaves on failure.

 Data is assigned to the new descriptor from the specified stream.

 This variant assumes that the stream contains the length of the data followed

 by the data itself.

 The function is implemented by calling the HBufC16::NewL(RReadStream&,TInt)

 variant and then assigning the resulting heap descriptor using

 the RBuf16::Assign(HBufC16*) variant. The comments that describe

 the HBufC16::NewL() variant	also apply to this RBuf16::CreateL() function.

 The function may leave with one of the system-wide error codes,	specifically 

 KErrOverflow, if the length of the data as read from the stream is greater than

 the upper limit as specified by the aMaxLength parameter.

 @param aStream    The stream from which the data length and the data to be

                   assigned to the new descriptor, are taken.

 @param aMaxLength The upper limit on the length of data that the descriptor is

                   to represent. The value of this parameter must be non-negative

                   otherwise the	underlying function will panic.

 */

 inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength)

 	{

 	Assign(HBufC16::NewL(aStream,aMaxLength));

 	}

 // Template class TLitC16

 template <TInt S>

 inline const TDesC16* TLitC16<S>::operator&() const

 /**

 Returns a const TDesC16 type pointer.

 @return A descriptor type pointer to this literal. 

 */

 	{return REINTERPRET_CAST(const TDesC16*,this);}

 template <TInt S>

 inline const TDesC16& TLitC16<S>::operator()() const

 /**

 Returns a const TDesC16 type reference.

 @return A descriptor type reference to this literal 

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC16<S>::operator const TDesC16&() const

 /**

 Invoked by the compiler when a TLitC16<TInt> type is passed to a function

 which is prototyped to take a const TDesC16& type.

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC16<S>::operator const __TRefDesC16() const

 /**

 Invoked by the compiler when a TLitC16<TInt> type is passed to a function

 which is prototyped to take a const TRefByValue<const TDesC16> type.

 @see __TRefDesC16

 */

 	{return *operator&();}

 #endif //__KERNEL_MODE__

 // Template class TBufC

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 template <TInt S>

 inline TBufC<S>::TBufC()

 	: TBufCBase16()

 /**

 Constructs an empty build independent non-modifiable buffer descriptor.

 It contains no data.

 The integer template parameter determines the size of the data area which 

 is created as part of the buffer descriptor object.

 Data can, subsequently, be assigned into this buffer descriptor using the 

 assignment operators.

 @see TBufC::operator=

 */

 	{}

 template <TInt S>

 inline TBufC<S>::TBufC(const TText *aString)

 	: TBufCBase16(aString,S)

 /** 

 Constructs a build independent non-modifiable 

 buffer descriptor from a zero terminated string.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 The string, excluding the zero terminator, is copied into this buffer descriptor's 

 data area. The length of this buffer descriptor is set to the length of the 

 string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 8,  if the length of the string, excluding the zero terminator, is

                 greater than the value of the integer template parameter for

 				the 16-bit build variant.

 @panic USER 20, if the length of the string, excluding the zero terminator, is

                 greater than the value of the integer template parameter for

 				the 8-bit build variant.

 */

 	{}

 template <TInt S>

 inline TBufC<S>::TBufC(const TDesC &aDes)

 	: TBufCBase16(aDes,S)

 /**

 Constructs a build-independent non-modifiable buffer descriptor from any 

 existing build independent descriptor.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 Data is copied from the source descriptor into this buffer descriptor and 

 the length of this buffer descriptor is set to the length of the source descriptor.

 The length of the source descriptor must not be greater than the value of 

 the integer template parameter, otherwise the constructor raises a USER 20 

 panic for an 8 bit build variant or a USER 8 panic for a 16 bit (Unicode) 

 build variant.

 @param aDes The source build independent non-modifiable descriptor.

 @panic USER 8,  if the length of the source descriptor is

                 greater than the value of the integer template parameter for

 				the 16-bit build variant.

 @panic USER 20, if the length of the source descriptor is

                 greater than the value of the integer template parameter for

 				the 8-bit build variant.

 */

 	{}

 #else

 template <TInt S>

 inline TBufC<S>::TBufC()

 	: TBufCBase8()

 	{}

 template <TInt S>

 inline TBufC<S>::TBufC(const TText *aString)

 	: TBufCBase8(aString,S)

 	{}

 template <TInt S>

 inline TBufC<S>::TBufC(const TDesC &aDes)

 	: TBufCBase8(aDes,S)

 	{}

 #endif

 template <TInt S>

 inline TBufC<S> &TBufC<S>::operator=(const TText *aString)

 /** 

 Copies data into this descriptor, replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aString A pointer to a zero-terminated string.

 @return A reference to this descriptor.

 @panic USER 11, if the length of the string, excluding the zero terminator,

                 is greater than the maximum length of this (target) descriptor

 				for the 16-bit build variant.

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the maximum length of this (target) descriptor

 				for the 8-bit build variant.

 */

 	{Copy(aString,S);return(*this);}

 template <TInt S>

 inline TBufC<S> &TBufC<S>::operator=(const TDesC &aDes)

 /**

 Copies data into this descriptor, replacing any existing data.

 The length of this descriptor is set to reflect the new data.

 @param aDes A build independent non-modifiable descriptor. 

 @return A reference to this descriptor.

 @panic USER 11, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor for the 16-bit

 				build variant.

 @panic USER 23, if the length of the descriptor aDes is greater than the

                 maximum length of this (target) descriptor for the 8-bit

 				build variant.

 */

 	{Copy(aDes,S);return(*this);}

 template <TInt S>

 inline TPtr TBufC<S>::Des()

 /**

 Creates and returns a build-independent modifiable pointer descriptor for

 the data represented by this build-independent non-modifiable buffer

 descriptor.

 The content of a non-modifiable buffer descriptor normally cannot be altered, 

 other than by complete replacement of the data. Creating a modifiable pointer 

 descriptor provides a way of changing the data.

 The modifiable pointer descriptor is set to point to this non-modifiable buffer 

 descriptor's data.

 The length of the modifiable pointer descriptor is set to the length of this 

 non-modifiable buffer descriptor.

 The maximum length of the modifiable pointer descriptor is set to the value 

 of the integer template parameter.

 When data is modified through this new pointer descriptor, the lengths of 

 both it and this constant buffer descriptor are changed.

 @return A build independent modifiable pointer descriptor representing the 

         data in this build independent non-modifiable buffer descriptor.

 */

 	{return(DoDes(S));}

 // Template class TBuf

 #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

 template <TInt S>

 inline TBuf<S>::TBuf()

 	: TBufBase16(S)

 /**

 Creates a build-independent modifiable buffer descriptor which 

 contains no data.

 The integer template parameter determines the size of the data area that is created 

 as part of the object, and defines the descriptor's maximum length.

 */

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(TInt aLength)

 	: TBufBase16(aLength,S)

 /**

 Constructs an empty build independent modifiable buffer descriptor and

 sets its length to the specified value.

 No data is assigned to the descriptor.

 The integer template parameter determines the size of the data area created 

 as part of the object and defines the descriptor's maximum length.

 @param aLength The length of this modifiable buffer descriptor.

 @panic USER 8,  if aLength is negative and is greater than the value of the

                 integer template parameter for a 16-bit build variant.

 @panic USER 20, if aLength is negative and is greater than the value of the

                 integer template parameter for a 8-bit build variant.

 */

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(const TText *aString)

 	: TBufBase16(aString,S)

 /**

 Constructs the build-independent modifiable buffer descriptor from

 a zero terminated string.

 The integer template parameter determines the size of the data area which 

 is created as part of this object.

 The string, excluding the zero terminator, is copied into this buffer

 descriptor's data area. The length of this buffer descriptor is set to

 the length of the string, excluding the zero terminator.

 @param aString A pointer to a zero terminated string.

 @panic USER 11, if the length of the string, excluding the zero terminator,

                 is greater than the value of the integer template parameter

 				for a 16-bit build variant.

 @panic USER 23, if the length of the string, excluding the zero terminator,

                 is greater than the value of the integer template parameter

 				for a 8-bit build variant.

 */

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(const TDesC &aDes)

 	: TBufBase16(aDes,S)

 /**

 Constructs the build-independent modifiable buffer descriptor from any

 existing build-independent descriptor.

 The integer template parameter determines the size of the data area created 

 as part of this object, and defines the descriptor's maximum length.

 Data is copied from the source descriptor into this modifiable buffer descriptor 

 and the length of this modifiable buffer descriptor is set to the length of 

 the source descriptor.

 @param aDes The source build independent non-modifiable descriptor.

 @panic USER 11, if the length of the source descriptor is greater than the

                 value of the integer template parameter for a 16-bit

 				build variant.

 @panic USER 23, if the length of the source descriptor is greater than the

                 value of the integer template parameter for an 8-bit

 				build variant.

 */

 	{}

 #else

 template <TInt S>

 inline TBuf<S>::TBuf()

 	: TBufBase8(S)

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(TInt aLength)

 	: TBufBase8(aLength,S)

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(const TText *aString)

 	: TBufBase8(aString,S)

 	{}

 template <TInt S>

 inline TBuf<S>::TBuf(const TDesC &aDes)

 	: TBufBase8(aDes,S)

 	{}

 #endif

 template <TInt S>

 inline TBuf<S> &TBuf<S>::operator=(const TText *aString)

 	{Copy(aString);return(*this);}

 template <TInt S>

 inline TBuf<S> &TBuf<S>::operator=(const TDesC &aDes)

 	{Copy(aDes);return(*this);}

 template <TInt S>

 inline TBuf<S> &TBuf<S>::operator=(const TBuf<S> &aBuf)

 	{Copy(aBuf);return(*this);}

 // Template class TLitC

 template <TInt S>

 inline const TDesC* TLitC<S>::operator&() const

 /**

 Returns a const TDesC type pointer.

 @return A descriptor type pointer to this literal. 

 */

 	{return REINTERPRET_CAST(const TDesC*,this);}

 template <TInt S>

 inline const TDesC& TLitC<S>::operator()() const

 /**

 Returns a const TDesC type reference.

 @return A descriptor type reference to this literal 

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC<S>::operator const TDesC&() const

 /**

 Invoked by the compiler when a TLitC<TInt> type is passed to a function

 which is prototyped to take a const TDesC& type.

 */

 	{return *operator&();}

 template <TInt S>

 inline TLitC<S>::operator const __TRefDesC() const

 /**

 Invoked by the compiler when a TLitC<TInt> type is passed to a function

 which is prototyped to take a const TRefByValue<const TDesC> type.

 @see __TRefDesC.

 */

 	{return *operator&();}

 // Template class TPckgC

 template <class T>

 inline TPckgC<T>::TPckgC(const T &aRef)

 	: TPtrC8((const TUint8 *)&aRef,sizeof(T))

 /**

 Constructs a packaged non-modifiable pointer descriptor to represent

 the specified object whose type is defined by the template parameter.

 @param aRef The object to be represented by this packaged non-modifiable 

             pointer descriptor.

 */

 	{}

 template <class T>

 inline const T &TPckgC<T>::operator()() const

 /**

 Gets a reference to the object represented by this packaged non-modifiable

 pointer descriptor.

 @return The packaged object 

 */

 	{return(*((const T *)iPtr));}

 // Template class TPckg

 template <class T>