diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kernel/eka/common/des8.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kernel/eka/common/des8.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,3960 @@ +// 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\common\des8.cpp +// +// + +#include "common.h" +#include +#ifndef __KERNEL_MODE__ +#include +#else +#include +#endif +#include + +// Folding/Collation for 8 bit characters + +extern const TUint8 __FoldCollTab8[256]; + +const TUint8 __FoldCollTab8[256] = + { + 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, // 0x00 + 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17, // 0x10 + 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f, + 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27, // 0x20 + 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37, // 0x30 + 0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f, + 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67, // 0x40 + 0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, // 0x50 + 0x78,0x79,0x7a,0x5b,0x5c,0x5d,0x5e,0x5f, + 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67, // 0x60 + 0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, // 0x70 + 0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f, + 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, // 0x80 + 0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f, + 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97, // 0x90 + 0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f, + 0x20,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7, // 0xa0 + 0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf, + 0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7, // 0xb0 + 0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf, + 0x61,0x61,0x61,0x61,0x61,0x61,0xe6,0x63, // 0xc0 + 0x65,0x65,0x65,0x65,0x69,0x69,0x69,0x69, + 0xf0,0x6e,0x6f,0x6f,0x6f,0x6f,0x6f,0xd7, // 0xd0 + 0xf8,0x75,0x75,0x75,0x75,0x79,0xfe,0xdf, + 0x61,0x61,0x61,0x61,0x61,0x61,0xe6,0x63, // 0xe0 + 0x65,0x65,0x65,0x65,0x69,0x69,0x69,0x69, + 0xf0,0x6e,0x6f,0x6f,0x6f,0x6f,0x6f,0xf7, // 0xf0 + 0xf8,0x75,0x75,0x75,0x75,0x79,0xfe,0x79 + }; + +#ifndef __KERNEL_MODE__ +inline TUint8* memCopy(TUint8* aPtr, const TUint8* aSrc, TInt aLength) +// +// Copy 8 bit values. +// + { + + return Mem::Copy(aPtr, aSrc, aLength); + } +#endif + +#if (defined(__KERNEL_MODE__) && !defined(__DES8_MACHINE_CODED__)) | defined(__EABI_CTORS__) +inline TInt StringLength(const TUint8* aPtr) + { + const TUint8* p = aPtr; + while (*p) + ++p; + return p-aPtr; + } +#endif + +inline TDesC8::TDesC8(TInt aType,TInt aLength) + :iLength(aLength|(aType<>KShiftDesType8); + } + +inline TDes8::TDes8(TInt aType,TInt aLength,TInt aMaxLength) + : TDesC8(aType,aLength),iMaxLength(aMaxLength) + {} + +// Class TBufCBase8 +inline TBufCBase8::TBufCBase8(TInt aLength) + :TDesC8(EBufC,aLength) + {} + +inline TUint8* TBufCBase8::WPtr() const + {return const_cast(Ptr());} + + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C const TUint8* TDesC8::Ptr() const +/** +Gets a pointer to the data represented by the descriptor. + +The data cannot be changed through the returned pointer. + +@return A pointer to the data +*/ + { + + switch (Type()) + { + case EBufC: + return(&((SBufC8 *)this)->buf[0]); + case EPtrC: + return(((SPtrC8 *)this)->ptr); + case EPtr: + return(((SPtr8 *)this)->ptr); + case EBuf: + return(&((SBuf8 *)this)->buf[0]); + case EBufCPtr: + return(&((SBufCPtr8 *)this)->ptr->buf[0]); + } + Panic(ETDes8BadDescriptorType); + return(NULL); + } + +EXPORT_C const TUint8 &TDesC8::AtC(TInt anIndex) const +// +// Return a reference to the character in the buffer. +// + { + + __ASSERT_ALWAYS(anIndex>=0 && anIndex0,Panic(ETDes8LengthNegative)); + const TUint8 *pB=Ptr(); + TInt aLenB=Length(); + const TUint8 *pC=pB-1; // using pre-increment addressing + TInt i=aLenB-aLenS; + if (i>=0) + { + const TUint8* pEndS=pS+aLenS-1; // using pre-increment addressing + const TUint8 *pEndB=pB+i; // using pre-increment addressing + TUint s=*pS; + for (;;) + { + do + { + if (pC==pEndB) + return KErrNotFound; + } while (*++pC!=s); + const TUint8 *p1=pC; + const TUint8 *p2=pS; + do + { + if (p2==pEndS) + return (pC-pB); + } while (*++p1==*++p2); + } + } + return(KErrNotFound); + } + +EXPORT_C TInt TDesC8::Find(const TDesC8 &aDes) const +/** +Searches for the first occurrence of the specified data sequence within this +descriptor. + +Searching always starts at the beginning of this descriptor's data. + +@param aDes The 8-bit non modifable descriptor containing the data sequence + to be searched for. + +@return The offset of the data sequence from the beginning of this descriptor's + data. KErrNotFound, if the data sequence cannot be found. +*/ + { + + return(Find(aDes.Ptr(),aDes.Length())); + } + +const TUint8* convTable(TMatchType aType) + { + switch (aType) + { + case EMatchFolded: + case EMatchCollated: return __FoldCollTab8; + default: return NULL; + } + } + +inline TUint conv(const TUint8* aStr,const TUint8* aConv) + { + TUint c=*aStr; + return aConv ? aConv[c] : c; + } + + +inline TUint lookup(const TUint8* aStr,const TUint8* aConv) + { + return aConv[*aStr]; + } + +TInt DoMatch8(const TDesC8 &aLeftD,const TDesC8 &aRightD,TMatchType aType) + { + const TUint8* table=convTable(aType); + const TUint8* pRight=aRightD.Ptr(); + const TUint8* pM=pRight-1; // pre-increment addressing + const TUint8* pP=pM+aRightD.Length(); + const TUint8* pLeft=aLeftD.Ptr()-1; // pre-increment addressing + const TUint8* pB=pLeft; + const TUint8* pE=pB+aLeftD.Length(); + + // Match any pattern up to the first star + TUint c; + for (;;) + { + if (pM==pP) // exhausted the pattern + return pB==pE ? 0 : KErrNotFound; + TUint c=conv(++pM,table); + if (c==KMatchAny) + break; + if (pB==pE) // no more input + return KErrNotFound; + if (c!=conv(++pB,table) && c!=KMatchOne) // match failed + return KErrNotFound; + } + // reached a star + if (pM==pP) + return 0; + TInt r=pM==pRight ? -1 : 0; + for (;;) + { + c=conv(++pM,table); + if (c==KMatchAny) + { +star: if (pM==pP) // star at end of pattern, always matches + return Max(r,0); + if (r<-1) // skipped some '?', matches at beginning + r=0; + continue; + } + if (pB==pE) // no more input + return KErrNotFound; + if (c==KMatchOne) + { // skip a character in the input + if (pM==pP) + return r+((r>=0) ? 0 : (pE-pLeft)); + ++pB; + if (r<0) + --r; + continue; + } + // Matching a non-wild character + for (;;) + { + if (table) // pull this test out of the tight loop (10-20% faster) + { + while (lookup(++pB,table)!=c) + { + if (pB==pE) // no more input + return KErrNotFound; + } + } + else + { + while (*++pB!=c) + { + if (pB==pE) // no more input + return KErrNotFound; + } + } + // Try to match up to the next star + const TUint8* pb=pB; + const TUint8* pm=pM; + for (;;) + { + if (pm=0 ? 0 : pB-pLeft); + pB=pb; + pM=pm; + goto star; + } + if (pb==pE) + return KErrNotFound; // no more input + if (cc!=conv(++pb,table) && cc!=KMatchOne) + break; // sub-match failed, try next input character + } + else if (pb==pE) // end of matching pattern + return r+(r>=0 ? 0 : pB-pLeft); // end of input, so have a match + else + break; // try next input character + } + } + } + } + +EXPORT_C TInt TDesC8::Match(const TDesC8 &aDes) const +/** +Searches this descriptor's data for a match with the match pattern supplied +in the specified descriptor. + +The match pattern can contain the wildcard characters "*" and "?", where "*" +matches zero or more consecutive occurrences of any character and "?" matches +a single occurrence of any character. + +Note that there is no 'escape character', which means that it is not possible +to match either the "*" character itself or the "?" character itself using +this function. + +@param aDes An 8-bit non-modifable descriptor containing the match pattern. + +@return If a match is found, the offset within this descriptor's data where + the match first occurs. KErrNotFound, if there is no match. +*/ + { + + return DoMatch8(*this,aDes,EMatchNormal); + } + +EXPORT_C TInt TDesC8::MatchF(const TDesC8 &aDes) const +/** +Searches this descriptor's folded data for a match with the folded match +pattern supplied in the specified descriptor. + +The match pattern can contain the wildcard characters "*" and "?", where "*" +matches zero or more consecutive occurrences of any character and "?" matches +a single occurrence of any character. + +Note that folding is locale-independent behaviour. It is also important to +note that there can be no guarantee that folding is in any way culturally +appropriate, and should not be used for matching strings in natural language; +use MatchC() for this. + +Note that there is no 'escape character', which means that it is not possible +to match either the "*" character itself or the "?" character itself using +this function. + +@param aDes An 8-bit non-modifable descriptor containing the match pattern. + +@return If a match is found, the offset within this descriptor's data where + the match first occurs. KErrNotFound, if there is no match. + +@see TDesC8::MatchC() +*/ + { + + return DoMatch8(*this,aDes,EMatchFolded); + } + +EXPORT_C TInt TDesC8::MatchC(const TDesC8 &aPattern) const +/** +Searches this descriptor's collated data for a match with the collated match +pattern supplied in the specified descriptor. + +The function uses the standard collation method for narrow text appropriate to +the current locale. + +The match pattern can contain the wildcard characters "*" and "?", where "*" +matches zero or more consecutive occurrences of any character and "?" matches +a single occurrence of any character. + +Note that there is no 'escape character', which means that it is not possible +to match either the "*" character itself or the "?" character itself using +this function. + +@param aPattern An 8-bit non-modifable descriptor containing the match pattern. + +@return If a match is found, the offset within this descriptor's data where + the match first occurs. KErrNotFound, if there is no match. +@deprecated +*/ + { +#ifndef __KERNEL_MODE__ + return MatchF(aPattern); +#else + return DoMatch8(*this,aPattern,EMatchCollated); +#endif + } + +#ifndef __KERNEL_MODE__ + +EXPORT_C TInt TDesC8::FindF(const TUint8 *pS,TInt aLenS) const +/** +Searches for the first occurrence of the specified folded data sequence within +this descriptor's folded data. + +Searching always starts at the beginning of this descriptor's data. + +Note that folding is locale-independent behaviour. It is also important to +note that there can be no guarantee that folding is in any way culturally +appropriate, and should not be used for finding strings in natural language; +use FindC() for this. + +@param pS A pointer to a location containing the data sequence to be + searched for. +@param aLenS The length of the data sequence to be searched for. This value + must not be negative, otherwise the function raises a panic. + +@return The offset of the data sequence from the beginning of this descriptor's + data. KErrNotFound, if the data sequence cannot be found. Zero, if the + length of the search data sequence is zero. + +@panic USER 29 if aLenS is negative + +@see TDesC8::FindC() +*/ + { + if (!aLenS) + return(0); + const TUint8* table=convTable(EMatchFolded); + const TUint8 *pB=Ptr(); + TInt aLenB=Length(); + const TUint8 *pC=pB-1; // using pre-increment addressing + TInt i=aLenB-aLenS; + if (i>=0) + { + const TUint8* pEndS=pS+aLenS-1; // using pre-increment addressing + const TUint8 *pEndB=pB+i; // using pre-increment addressing + TUint s=lookup(pS,table); + for (;;) + { + do + { + if (pC==pEndB) + return KErrNotFound; + } while (lookup(++pC,table)!=s); + const TUint8 *p1=pC; + const TUint8 *p2=pS; + do + { + if (p2==pEndS) + return (pC-pB); + } while (lookup(++p1,table)==lookup(++p2,table)); + } + } + return(KErrNotFound); + } + +EXPORT_C TInt TDesC8::FindF(const TDesC8 &aDes) const +/** +Searches for the first occurrence of the specified folded data sequence within +this descriptor's folded data. + +Searching always starts at the beginning of this descriptor's data. + +Note that folding is locale-independent behaviour. It is also important to +note that there can be no guarantee that folding is in any way culturally +appropriate, and should not be used for finding strings in natural language; +use FindC() for this. + +@param aDes The 8-bit non-modifable descriptor containing the data sequence + to be searched for. + +@return The offset of the data sequence from the beginning of this descriptor's + data. KErrNotFound, if the data sequence cannot be found. Zero, if the + length of the search data sequence is zero. + +@see TDesC8::FindC() +*/ + { + + return(FindF(aDes.Ptr(),aDes.Length())); + } + +EXPORT_C TInt TDesC8::FindC(const TUint8* aText,TInt aLength) const +/** +Searches for the first occurrence of the specified collated data sequence within +this descriptor's collated data. + +Searching always starts at the beginning of this descriptor's data. The function +uses the standard collation method for narrow text appropriate to the current +locale. + +@param aText A pointer to a location containing the data sequence to be + searched for. +@param aLength The length of the data sequence to be searched for. + +@return The offset of the data sequence from the beginning of this descriptor's + data. KErrNotFound, if the data sequence cannot be found. + +@panic USER 29 if aLength is negative. +@deprecated +*/ + { + return FindF(aText, aLength); + } + +EXPORT_C TInt TDesC8::FindC(const TDesC8 &aDes) const +/** +Searches for the first occurrence of the specified collated data sequence within +this descriptor's collated data. + +Searching always starts at the beginning of this descriptor's data. The function +uses the standard collation method for narrow text appropriate to the current +locale. + +@param aDes The 8-bit non-modifable descriptor containing the data sequence + to be searched for. + +@return The offset of the data sequence from the beginning of this descriptor's + data. KErrNotFound, if the data sequence cannot be found. +@deprecated +*/ + { + + return(FindC(aDes.Ptr(),aDes.Length())); + } + +EXPORT_C TInt TDesC8::LocateF(TChar aChar) const +/** +Searches for the first occurrence of a folded character within this +descriptor's folded data. + +The search starts at the beginning of the data,i.e. at the leftmost position. + +Note that folding is locale-independent behaviour. It is also important to +note that there can be no guarantee that folding is in any way culturally +appropriate, and should not be used for searching strings in natural language. + +@param aChar The character to be found. + +@return The offset of the character position from the beginning of the data. + KErrNotFound, if no matching character can be found. +*/ + { + TUint c = User::Fold(aChar); + if(c>=0x100) + return KErrNotFound; + const TUint8 *pBuf=Ptr(); + const TUint8 *pB=pBuf-1; + const TUint8 *pE=pB+Length(); + const TUint8* table=__FoldCollTab8; + do + { + if (pB==pE) + return KErrNotFound; + } while (table[*++pB]!=c); + return pB-pBuf; + } +#endif // __KERNEL_MODE__ + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C TInt TDesC8::Locate(TChar aChar) const +/** +Searches for the first occurrence of a character within this descriptor's +data. + +The search starts at the beginning of the data, i.e. at the leftmost position. + +@param aChar The character to be found. + +@return The offset of the character position from the beginning of the data. + KErrNotFound, if no matching character can be found. +*/ + { + + const TUint8 *pBuf=Ptr(); + const TUint8 *pB=pBuf-1; + const TUint8 *pE=pB+Length(); + do + { + if (pB==pE) + return KErrNotFound; + } while (*++pB!=aChar); + return pB-pBuf; + } +#endif + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C TInt TDesC8::LocateReverse(TChar aChar) const +/** +Searches for the first occurrence of a character within this descriptor's data, +searching from the end of the data. + +The search starts at the rightmost position. + +@param aChar The character to be found. + +@return The offset of the character position from the beginning of the data. + KErrNotFound, if no matching character can be found. +*/ + { + + TInt len=Length(); + if (len==0) + return(KErrNotFound); + const TUint8 *pB=Ptr(); + const TUint8 *pE=pB+len-1; + while (pE>=pB) + { + if (*pE==aChar) + break; + pE--; + } + return(pE=pB) + { + if (table[*pE]==c) + break; + pE--; + } + return(pE=0,Panic(ETDes8PosOutOfRange)); + return(TPtrC8(Ptr(),Min(aLength,Length()))); + } + +EXPORT_C TPtrC8 TDesC8::Right(TInt aLength) const +/** +Extracts the rightmost part of the data. + +The function does not cut or remove any data but constructs a non-modifiable +pointer descriptor to represent the rightmost part of the data. + +@param aLength The length of data to be extracted. If this value + is greater than the length of the descriptor, the function + extracts the whole of the descriptor. + +@return The 8 bit non-modifiable pointer descriptor representing the rightmost + part of the data. + +@panic USER 22 if aLength is negative. +*/ + { + + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8PosOutOfRange)); + TInt len=Length(); + if (aLength>len) + aLength=len; + return(TPtrC8(Ptr()+len-aLength,aLength)); + } + +EXPORT_C TPtrC8 TDesC8::Mid(TInt aPos) const +/** +Extracts a portion of the data. + +The function does not cut or remove any data but constructs a non-modifiable +pointer descriptor to represent the defined portion. + +The portion is identified by its starting position and by the length of the +remainder of the data starting from the specified position. + +@param aPos The starting position of the data to be extracted. This is an + offset value; a zero value refers to the leftmost data position. + +@return The 8-bit non-modifiable pointer descriptor representing the specified + portion of the data. + +@panic USER 22 if aPos is negative or aPos is greater than the + length of the descriptor. +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange)); + return(TPtrC8(Ptr()+aPos,len-aPos)); + } + +EXPORT_C TPtrC8 TDesC8::Mid(TInt aPos,TInt aLength) const +/** +Extracts a portion of the data. + +The function does not cut or remove any data but constructs a non-modifiable +pointer descriptor to represent the defined portion. + +The portion is identified by its starting position and by its length. + +@param aPos The starting position of the data to be extracted. This is an + offset value; a zero value refers to the leftmost data position. +@param aLength The length of data to be extracted. + +@return The 8 bit non-modifiable pointer descriptor representing the specified + portion of the data. + +@panic USER 22 if aPos is negative or aPos plus aLength is greater than the + length of the descriptor. +*/ + { + + __ASSERT_ALWAYS(aPos>=0 && (aPos+aLength)<=Length(),Panic(ETDes8PosOutOfRange)); + return(TPtrC8(Ptr()+aPos,aLength)); + } + +#endif // !defined(__DES8_MACHINE_CODED__) + +#if !defined( __DES8_MACHINE_CODED__) | defined(__EABI_CTORS__) +EXPORT_C TBufCBase8::TBufCBase8() +// +// Constructor +// + : TDesC8(EBufC,0) + {} + +EXPORT_C TBufCBase8::TBufCBase8(const TUint8 *aString,TInt aMaxLength) +// +// Constructor +// + : TDesC8(EBufC,0) + { + Copy(aString,aMaxLength); + } + +EXPORT_C TBufCBase8::TBufCBase8(const TDesC8 &aDes,TInt aMaxLength) +// +// Constructor +// + : TDesC8(EBufC,0) + { + Copy(aDes,aMaxLength); + } +#endif + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C void TBufCBase8::Copy(const TUint8 *aString,TInt aMaxLength) +// +// Copy from a string. +// + { + + TInt len=STRING_LENGTH(aString); + __ASSERT_ALWAYS(len<=aMaxLength,Panic(ETDes8Overflow)); + memmove(WPtr(), aString, len); + DoSetLength(len); + } + +EXPORT_C void TBufCBase8::Copy(const TDesC8 &aDes,TInt aMaxLength) +// +// Copy from a descriptor. +// + { + + TInt len=aDes.Length(); + __ASSERT_ALWAYS(len<=aMaxLength,Panic(ETDes8Overflow)); + memmove(WPtr(), aDes.Ptr(), len); + DoSetLength(len); + } +#endif + +#ifndef __KERNEL_MODE__ +inline HBufC8::HBufC8(TInt aLength) + :TBufCBase8(aLength) + {} + +EXPORT_C HBufC8 *HBufC8::New(TInt aMaxLength) +/** +Creates, and returns a pointer to, a new 8-bit heap descriptor. + +The heap descriptor is empty and its length is zero. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger + than requested. + +@return A pointer to the new 8-bit heap descriptor. NULL, if the 8-bit heap + descriptor cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + return new(STD_CLASS::Alloc(_FOFF(HBufC8,iBuf[aMaxLength]))) HBufC8(0); + } + +EXPORT_C HBufC8 *HBufC8::NewL(TInt aMaxLength) +/** +Creates, and returns a pointer to, a new 8-bit heap descriptor, and leaves +on failure. + +The heap descriptor is empty and its length is zero. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger + than requested. + +@return A pointer to the new 8 bit heap descriptor. The function leaves, if + the new 8-bit heap descriptor cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + return static_cast(User::LeaveIfNull(New(aMaxLength))); + } + +EXPORT_C HBufC8 *HBufC8::NewLC(TInt aMaxLength) +/** +Creates, adds a pointer onto the cleanup stack, and returns a pointer to, a +new 8 bit heap descriptor; leaves on failure. + +The heap descriptor is empty and its length is zero. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger + than requested. + +@return A pointer to the new 8-bit heap descriptor. The function leaves, if + the new 8-bit heap descriptor cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + HBufC8* buf=NewL(aMaxLength); + CleanupStack::PushL(buf); + return buf; + } + +EXPORT_C HBufC8 *HBufC8::NewMax(TInt aMaxLength) +/** +Creates, and returns a pointer to, a new 8-bit heap descriptor. + +No data is assigned into the new descriptor but its length +is set to aMaxLength. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger + than requested. This also means that the resulting maximum + length of the descriptor may be greater than its length. + +@return A pointer to the new 8-bit heap descriptor. NULL, if the new 8-bit + heap descriptor cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + return new(STD_CLASS::Alloc(_FOFF(HBufC8,iBuf[aMaxLength]))) HBufC8(aMaxLength); + } + +EXPORT_C HBufC8 *HBufC8::NewMaxL(TInt aMaxLength) +/** +Creates, and returns a pointer to, a new 8-bit heap descriptor; +leaves on failure. + +No data is assigned into the new descriptor but its length +is set to aMaxLength. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger + than requested. This also means that the resulting maximum + length of the descriptor may be greater than its length. + +@return A pointer to the new 8-bit heap descriptor. The function leaves, if + the new 8-bit heap descriptor cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + return static_cast(User::LeaveIfNull(NewMax(aMaxLength))); + } + +EXPORT_C HBufC8 *HBufC8::NewMaxLC(TInt aMaxLength) +/** +Creates, adds a pointer onto the cleanup stack and returns a pointer to, a +new 8-bit heap descriptor; leaves on failure. + +No data is assigned into the new descriptor but its length +is set to aMaxLength. + +Data can, subsequently, be assigned into it using the assignment operators. + +@param aMaxLength The requested maximum length of the descriptor. Note that + the resulting heap cell size and, therefore, the resulting + maximum length of the descriptor may be larger than requested. + This also means that the resulting maximum + length of the descriptor may be greater than its length. + +@return A pointer to the new 8-bit heap descriptor. This is also put onto the + cleanup stack. The function leaves, if the new 8-bit heap descriptor + cannot be created. + +@panic USER 30 if aMaxLength is negative. + +@see HBufC8::operator=() +*/ + { + HBufC8* buf=NewMaxL(aMaxLength); + CleanupStack::PushL(buf); + return buf; + } + +EXPORT_C HBufC8 &HBufC8::operator=(const TUint8 *aString) +/** +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 aString A pointer to a zero-terminated string. + +@return A reference to this 8 bit heap 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,(STD_CLASS::AllocLen(this)-sizeof(TDesC8))/sizeof(TUint8)); + return(*this); + } + +EXPORT_C HBufC8 &HBufC8::operator=(const TDesC8 &aDes) +/** +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 aDes An 8-bit non-modifiable descriptor. + +@return A reference to this 8-bit heap descriptor. + +@panic USER 23 if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor +*/ + { + + Copy(aDes,(STD_CLASS::AllocLen(this)-sizeof(TDesC8))/sizeof(TUint8)); + return(*this); + } + +EXPORT_C HBufC8 *HBufC8::ReAlloc(TInt aMaxLength) +/** +Expands or contracts the heap descriptor. + +This is done by: + +1. creating a new heap descriptor. + +2. copying the original data into the new descriptor. + +3. deleting the original descriptor. + +@param aMaxLength The new requested maximum length of the descriptor. + Note that the resulting heap cell size and, therefore, + the resulting maximum length of the descriptor may be + larger than requested. + +@return A pointer to the new expanded or contracted 8 bit heap descriptor - + the original descriptor is deleted. NULL, if the new 8-bit heap descriptor + cannot be created - the original descriptor remains unchanged + +@panic USER 26 if aMaxLength is less than the length of the existing data. +@panic USER 30 if aMaxLength is negative. +*/ + { + + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + __ASSERT_ALWAYS(Length()<=aMaxLength,Panic(ETDes8ReAllocTooSmall)); + return((HBufC8 *)STD_CLASS::ReAlloc(this,(aMaxLength*sizeof(TUint8))+sizeof(TDesC8))); + } + +EXPORT_C HBufC8 *HBufC8::ReAllocL(TInt aMaxLength) +/** +Expands or contracts the descriptor; leaves on failure. + +This is done by: + +1. creating a new heap descriptor. + +2. copying the original data into the new descriptor. + +3. deleting the original descriptor. + +@param aMaxLength The new requested maximum length of the descriptor. + Note that the resulting heap cell size and, therefore, + the resulting maximum length of the descriptor may be + larger than requested. + +@return A pointer to the new expanded or contracted 8 bit heap descriptor - + the original descriptor is deleted. NULL, if the new 8-bit heap descriptor + cannot be created - the original descriptor remains unchanged + +@panic USER 26 if aMaxLength is less than the length of the existing data. +@panic USER 30 if aMaxLength is negative. +*/ + { + + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + __ASSERT_ALWAYS(Length()<=aMaxLength,Panic(ETDes8ReAllocTooSmall)); + return((HBufC8 *)STD_CLASS::ReAllocL(this,(aMaxLength*sizeof(TUint8))+sizeof(TDesC8))); + } + +EXPORT_C TPtr8 HBufC8::Des() +/** +Creates and returns an 8-bit modifiable pointer descriptor for the data +represented by this 8-bit heap descriptor. + +The content of a heap 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 heap descriptor's +data. + +The length of the modifiable pointer descriptor is set to the length of this +heap descriptor. + +The maximum length of the modifiable pointer descriptor is set to the length +of the heap descriptor's buffer. Note that the maximum length is the length +of the descriptor buffer in the allocated host heap cell; this may be greater +than the maximum length requested when this descriptor was originally created +or last re-allocated. + +When data is modified through this new pointer descriptor, the lengths of +both it and this heap descriptor are changed. + +Note that it is a common mistake to use Des() to create a TDesC8& reference. +While not incorrect, it is simpler and much more efficient to simply dereference +the heap descriptor. + +@return An 8-bit modifiable pointer descriptor representing the data in this + 8-bit heap descriptor. +*/ + { + return DoDes((STD_CLASS::AllocLen(this)-sizeof(TDesC8))/sizeof(TUint8)); + } +#endif // __KERNEL_MODE__ + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C void TDes8::SetLength(TInt aLength) +/** +Sets the length of the data represented by the descriptor to the +specified value. + +@param aLength The new length of the descriptor. + +@panic USER 23 if alength is negative or is greater than the maximum length of + this (target) descriptor. +*/ + { + + __ASSERT_ALWAYS(TUint(aLength)<=TUint(MaxLength()),Panic(ETDes8Overflow)); + DoSetLength(aLength); + if (Type()==EBufCPtr) + ((SBufCPtr8 *)this)->ptr->length=aLength; // Relies on iType==0 for an TBufC + } + +EXPORT_C void TDes8::SetMax() +/** +Sets the length of the data to the maximum length of the descriptor. +*/ + { + + SetLength(iMaxLength); + } + +EXPORT_C void TDes8::Copy(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. + +@panic USER 23 if the length of aString, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + { + + TInt len=STRING_LENGTH(aString); + SetLength(len); + memmove(WPtr(), aString, len); + } + +EXPORT_C void TDes8::Copy(const TUint8 *aBuf,TInt aLength) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aBuf The start address of data to be copied. +@param aLength The length of data to be copied. + +@panic USER 23 if aLength is greater than the maximum length of + this (target) descriptor. +*/ + { + + SetLength(aLength); + memmove(WPtr(), aBuf, aLength); + } + +EXPORT_C void TDes8::Copy(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. The length of the data cannot + be greater than the maximum length of the target descriptor. + +@panic USER 23 if the length of aDes is greater than the maximum length of + this (target) descriptor. +*/ + { + + TInt len=aDes.Length(); + SetLength(len); + memmove(WPtr(), aDes.Ptr(), len); + } +#endif + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::Copy(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. Each double-byte value can + only be copied into the corresponding single byte when the + double-byte value is less than decimal 256. A double-byte value of + 256 or greater cannot be copied and the corresponding single byte + is set to a value of decimal 1. + +@panic USER 23 if the length of the aDes is greater than the maximum length + of this (target) descriptor. +*/ + { + + TInt len=aDes.Length(); + SetLength(len); + const TUint16 *pS=aDes.Ptr(); + const TUint16 *pE=pS+len; + TUint8 *pT=WPtr(); + while (pS=0x100) + c=1; + *pT++=(TUint8)c; + } + } +#endif + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C void TDes8::Append(TChar aChar) +/** +Appends a character onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +@param aChar The single character to be appended. The length of the descriptor + is incremented by one. The function assumes that the character + is non-Unicode and that it can be represented by a single byte. + +@panic USER 23 if the resulting new length of this descriptor is greater than + its maximum length. +*/ + { + + TInt len=Length(); + TUint8 *pB=WPtr()+len; + SetLength(len+1); + *pB++=(TUint8)aChar; + } + +EXPORT_C void TDes8::Append(const TUint8 *aBuf,TInt aLength) +/** +Appends data onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +@param aBuf A pointer to the data to be copied. +@param aLength The length of the data to be copied. + +@panic USER 23 if the resulting new length of this descriptor is greater than + its maximum length. +@panic USER 29 if aLength is negative. +*/ + { + + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8LengthNegative)); + TInt len=Length(); + SetLength(len+aLength); + memmove(WPtr()+len, aBuf, aLength); + } + +EXPORT_C void TDes8::Append(const TDesC8 &aDes) +/** +Appends data onto the end of this descriptor's data. + +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. + +@panic USER 23 if the resulting new length of this descriptor is greater than + its maximum length. +*/ + { + + TInt len=Length(); + TInt n=aDes.Length(); + SetLength(len+n); + memmove(WPtr()+len, aDes.Ptr(), n); + } +#endif + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::Append(const TDesC16 &aDes) +/** +Appends data onto the end of this descriptor's data. + +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. + Each double-byte value can only be appended as a single byte when + the double-byte value is less than decimal 256. A double-byte value + of 256 or greater cannot be appended and the corresponding single + byte is set to a value of decimal 1. + +@panic USER 23 if the resulting new length of this descriptor is greater than + its maximum length. +*/ + { + + TInt len=Length(); + TInt n=aDes.Length(); + const TUint16* pS=aDes.Ptr(); + const TUint16* pE=pS+n; + TUint8 *pT=WPtr()+len; + SetLength(len+n); + while (pS=0x100) + c=1; + *pT++=(TUint8)c; + } + } +#endif + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::Swap(TDes8 &aDes) +/** +Swaps the data represented by this descriptor with the data represented by +the specified descriptor. + +The lengths of both descriptors are swapped to reflect the change. + +Note that each descriptor must be capable of accommodating the contents of +the other descriptor. + +@param aDes The 8-bit modifiable descriptor whose data is to be swapped with + the data of this descriptor. + +@panic USER 23 if the maximum length of either descriptor is smaller than the + length of the other descriptor. +*/ + { + + TInt l=Length(); + TInt r=aDes.Length(); + aDes.SetLength(l); + SetLength(r); + TInt s=Min(l,r); + l-=s; + r-=s; + TUint8 *pL=WPtr(); + TUint8 *pR=aDes.WPtr(); + while (s--) + { + TChar a=(*pL); + *pL++=(*pR); + *pR++=(TUint8)a; + } + while (l--) + *pR++=(*pL++); + while (r--) + *pL++=(*pR++); + } +#endif + +#ifndef __DES8_MACHINE_CODED__ +EXPORT_C void TDes8::Fill(TChar aChar) +/** +Fills the descriptor's data area with the specified character, replacing any +existing data. + +The descriptor is filled from the beginning up to its current length. The +descriptor's length does not change. It is not filled to its maximum length. + +@param aChar The fill character. The function assumes that the character is + non-Unicode, and that it can be represented by a single byte. +*/ + { + + memset(WPtr(), (TInt)(aChar.operator TUint()), Length()); + } +#endif + +EXPORT_C void TDes8::Fill(TChar aChar,TInt aLength) +/** +Fills the descriptor's data area with the specified character, replacing any +existing data. + +The descriptor is filled with the specified number of characters. +and its length is changed to reflect this. + +@param aChar The fill character. The function assumes that the character is + non-Unicode, and that it can be represented by a single byte. +@param aLength The new length of the descriptor and the number of fill + characters to be copied into it. + +@panic USER 23 if aLength is negative or is greater than the maximum length + of this descriptor. +*/ + { + + SetLength(aLength); + memset(WPtr(), (TInt)(aChar.operator TUint()), aLength); + } + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::AppendFill(TChar aChar,TInt aLength) +/** +Appends and fills this descriptor with the specified character. + +The descriptor is appended with the specified number of characters. +and its length is changed to reflect this. + +@param aChar The fill character. The function assumes that the character + is non-Unicode and that it can be represented by a single byte. +@param aLength The number of fill characters to be appended. + +@panic USER 23 if aLength is negative, or the resulting length of this + descriptor is greater than its maximum length. +*/ + { + + TInt len=Length(); + SetLength(len+aLength); + memset(WPtr()+len, (TInt)(aChar.operator TUint()), aLength); + } +#endif + +#ifndef __DES8_MACHINE_CODED__ +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::ZeroTerminate() +/** +Appends a zero terminator onto the end of this descriptor's data. + +The length of the descriptor is not changed. It must, however, be strictly +less than the descriptor's maximum length. +This condition guarantees that there is sufficient space for the +zero terminator. + +@panic USER 23 if the descriptor's length is not strictly less than its + maximum length. +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(len=0,Panic(ETDes8LengthNegative)); + TUint8 *pB=WPtr(); + TInt len=Length(); + if (len && aLength) + { + while (len) + { + TInt i=Min(len,aLength); + pB=memCopy(pB,aBuf,i); + len-=i; + } + } + } + +EXPORT_C void TDes8::Repeat(const TDesC8 &aDes) +/** +Copies data with repetition into this descriptor, from another descriptor, +replacing any existing data. + +Copying proceeds until this descriptor is filled up to its current length. +If it cannot contain a whole number of copies of the source data, then the +last copy is truncated. + +@param aDes An 8-bit non-modifiable descriptor whose data is to be repeatedly + copied. +*/ + { + + Repeat(aDes.Ptr(),aDes.Length()); + } + +EXPORT_C void TDes8::Trim() +/** +Deletes leading and trailing whitespace characters from the descriptor's data. + +The length of the descriptor is reduced to reflect the loss of the whitespace characters. + +@see TDes8::TrimLeft() +@see TDes8::TrimRight() +*/ + { + + TrimLeft(); + TrimRight(); + } + +EXPORT_C void TDes8::TrimAll() +/** +Deletes leading and trailing whitespace characters from the descriptor's data and +replaces each contiguous set of whitespace characters within the data by one whitespace +character. + +The length of the descriptor is reduced to reflect the loss of the whitespace +characters. + +@see TDes8::Trim() +*/ + { + + TrimLeft(); + TrimRight(); + TUint8 *pBuf=(TUint8 *)Ptr(); + TUint8 *pSrc=pBuf; + TUint8 *pDst=pBuf; + TInt len=Length(); + TInt spaces=0; + while (len--) + { + TChar c=*pSrc; + if (c.IsSpace()) + { + if (spaces++==0) + { + if (pDst!=pSrc) + *pDst=*pSrc; + pDst++; + } + } + else + { + spaces=0; + if (pDst!=pSrc) + *pDst=*pSrc; + pDst++; + } + pSrc++; + } + Delete(pDst-pBuf, pSrc-pDst); + } + +EXPORT_C void TDes8::TrimLeft() +/** +Deletes leading whitespace characters from the descriptor's data. + +All whitespace characters up to, but not including the first non-whitespace +character, are deleted. + +The length of the descriptor is reduced to reflect the loss of the +whitespace characters. +*/ + { + + const TUint8 *pBuf=Ptr(); + const TUint8 *pB=pBuf; + TInt len=Length(); + while (len--) + { + TChar c=(*pB); + if (!c.IsSpace()) + break; + pB++; + } + Delete(0,pB-pBuf); + } + +EXPORT_C void TDes8::TrimRight() +/** +Deletes trailing whitespace characters from the descriptor's data. + +The process starts on the right hand side of the descriptor's data +and proceeds to the left. + +All whitespace characters up to, but not including the first non-whitespace character, +are deleted. + +The length of the descriptor is reduced to reflect the loss of the whitespace +characters. +*/ + { + + TInt len=Length(); + if (len==0) + return; + const TUint8 *pB=Ptr()+len-1; + TInt s=len; + while (s) + { + TChar c=(*pB--); + if (!c.IsSpace()) + break; + s--; + } + Delete(s,len-s); + } + +EXPORT_C void TDes8::Insert(TInt aPos,const TDesC8 &aDes) +/** +Inserts data into this descriptor. + +The length of this descriptor is changed to reflect the extra data. + +@param aPos The position within the data where insertion is to start. This + is an offset value; a zero value refers to the leftmost data + position. + +@param aDes An 8 bit non modifiable descriptor whose data is to be inserted. + +@panic USER 22 if aPos is negative or is greater than the length of this + descriptor. +@panic USER 23 if the resulting length of this descriptor is greater than its + maximum length. +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange)); + TInt s=aDes.Length(); + __ASSERT_ALWAYS((len+s)<=MaxLength(),Panic(ETDes8Overflow)); + TUint8 *pB=WPtr(); + memmove(pB+aPos+s,pB+aPos,len-aPos); + memmove(pB+aPos,aDes.Ptr(),aDes.Length()); + SetLength(len+s); + } + +EXPORT_C void TDes8::Delete(TInt aPos,TInt aLength) +/** +Deletes data from this descriptor. + +The length of this descriptor is changed to reflect the loss of data. + +@param aPos The position within the data where deletion is to start. This + is an offset value; a zero value refers to the leftmost data + position. + +@param aLength The length of data to be deleted. If necessary, the function + adjusts this value to ensure that no data beyond the end of the + descriptor data area is deleted. + +@panic USER 22 if aPos is negative or is greater than the length of this + descriptor. +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange)); + TInt d=Min(len-aPos,aLength); + TUint8 *pB=WPtr(); + memmove(pB+aPos,pB+aPos+d,len-aPos-d); + SetLength(len-d); + } + +EXPORT_C void TDes8::Replace(TInt aPos,TInt aLength,const TDesC8 &aDes) +/** +Replaces data in this descriptor. + +The specified length can be different to the length of the replacement data. +The length of this descriptor changes to reflect the change of data. + +@param aPos The position within the data where replacement is to start. + This is an offset value; a zero value refers to the leftmost + data position. + +@param aLength The length of data to be replaced. + +@param aDes The source 8-bit non-modifiable descriptor whose data is to + replace the target descriptor's data at aPos. + +@panic USER 20 if aLength is negative or the sum of aLength and aPos is + greater than the length of this descriptor. + +@panic USER 22 if aPos is negative or is greater than the length of this + descriptor. + +@panic USER 23 if the resulting length of this descriptor is greater than its + maximum length. + +@panic USER 28 if the length of the source descriptor aDes is negative or is + greater than the maximum length of this target descriptor, +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange)); + __ASSERT_ALWAYS(aLength>=0 && aPos+aLength<=len,Panic(ETDes8LengthOutOfRange)); + TInt s=aDes.Length(); + TInt maxlen=MaxLength(); + __ASSERT_ALWAYS(s>=0 && s<=maxlen,Panic(ETDes8RemoteLengthOutOfRange)); + __ASSERT_ALWAYS((len+s-aLength)<=maxlen,Panic(ETDes8Overflow)); + TUint8 *pB=WPtr(); + memmove(pB+aPos+s,pB+aPos+aLength,len-aPos-aLength); + memmove(pB+aPos,aDes.Ptr(),s); + SetLength(len+s-aLength); + } + +EXPORT_C void TDes8::Justify(const TDesC8 &aDes,TInt aWidth,TAlign anAlignment,TChar aFill) +/** +Copies data into this descriptor and justifies it, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +The target area is considered to be an area of specified width positioned at +the beginning of this descriptor's data area. Source data is copied into, and +aligned within this target area according to the specified alignment +instruction. + +If the length of the target area is larger than the length of the source, then +spare space within the target area is padded with the fill character. + +@param aDes An 8-bit non-modifiable descriptor containing the source data. + The length of the data to be copied is the smaller of: + the length of the source descriptor, and + the width of the target area (only if this is not the + explicit negative value KDefaultJustifyWidth). + +@param aWidth The width of the target area. If this has the specific + negative value KDefaultJustifyWidth, then the width is + re-set to the length of the data source. + +@param anAlignment The alignment of the data within the target area + +@param aFill The fill character used to pad the target area. + +@panic USER 23 if the resulting length of this descriptor is greater than + its maximum length or aWidth has a negative value other + than KDefaultJustifyWidth. +*/ + { + + Zero(); + AppendJustify(aDes.Ptr(),aDes.Length(),aWidth,anAlignment,aFill); + } + +EXPORT_C void TDes8::AppendJustify(const TDesC8 &aDes,TInt aWidth,TAlign anAlignment,TChar aFill) +/** +Appends data onto the end of this descriptor's data and justifies it. + +The source of the appended data is an existing descriptor. + +The target area is considered to be an area of specified width, immediately +following this descriptor's existing data. Source data is copied into, and +aligned within this target area according to the specified alignment instruction. + +If the length of the target area is larger than the length of the source, +then spare space within the target area is padded with the fill character. + +@param aDes An 8-bit non-modifiable descriptor containing the source + data. The length of the data to be copied is the smaller of: + the length of the source descriptor, and + the width of the target area (only if this is not the + explicit negative value KDefaultJustifyWidth). + +@param aWidth The width of the target area. If this has the specific + negative value KDefaultJustifyWidth, then the width is + re-set to the length of the data source. + +@param anAlignment The alignment of the data within the target area. + +@param aFill The fill character used to pad the target area. + +@panic USER 23 if the resulting length of this descriptor is greater than + its maximum length or aWidth has a negative value other + than KDefaultJustifyWidth. +*/ + { + + AppendJustify(aDes.Ptr(),aDes.Length(),aWidth,anAlignment,aFill); + } + +EXPORT_C void TDes8::AppendJustify(const TDesC8 &aDes,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill) +/** +Appends data onto the end of this descriptor's data and justifies it. + +The source of the appended data is an existing descriptor. + +The target area is considered to be an area of specified width, immediately +following this descriptor's existing data. Source data is copied into, and +aligned within this target area according to the specified alignment instruction. + +If the length of the target area is larger than the length of the source, +then spare space within the target area is padded with the fill character. + +@param aDes An 8-bit non-modifiable descriptor containing the source data. + +@param aLength The length of data to be copied from the source descriptor. + If this is greater than the width of the target area, then + the length of data copied is limited to the width. + The length of data to be copied must not be greater than + the length of the source descriptor. Note that this + condition is not automatically tested. + +@param aWidth The width of the target area. If this has the specific negative + value KDefaultJustifyWidth, then the width is + re-set to the length of the data source. + +@param anAlignment The alignment of the data within the target area. + +@param aFill The fill character used to pad the target area. + +@panic USER 23 if the resulting length of this descriptor is greater than + its maximum length or aWidth has a negative value other + than KDefaultJustifyWidth. +*/ + { + + AppendJustify(aDes.Ptr(),aLength,aWidth,anAlignment,aFill); + } + +EXPORT_C void TDes8::AppendJustify(const TUint8 *aString,TInt aWidth,TAlign anAlignment,TChar aFill) +/** +Appends a zero terminated string onto the end of this descriptor's data and +justifies it. + +The zero terminator is not copied. + +The target area is considered to be an area of specified width, immediately +following this descriptor's existing data. Source data is copied into, and +aligned within, this target area according to the specified alignment instruction. + +If the length of the target area is larger than the length of the source, +then spare space within the target area is padded with the fill character. + +@param aString A pointer to a zero terminated string. The length of the + data to be copied is the smaller of: + the length of the string (excluding the zero terminator), + and the width of the target area (only if this is not the + explicit negative value KDefaultJustifyWidth). + +@param aWidth The width of the target area. If this has the specific + negative value KDefaultJustifyWidth, then the width + is re-set to the length of the zero terminated string + (excluding the zero terminator). + +@param anAlignment The alignment of the data within the target area. + +@param aFill The fill character used to pad the target area. + +@panic USER 23 if the resulting length of this descriptor is greater than + its maximum length or aWidth has a negative value other + than KDefaultJustifyWidth. +*/ + { + + AppendJustify(aString,STRING_LENGTH(aString),aWidth,anAlignment,aFill); + } + +EXPORT_C void TDes8::AppendJustify(const TUint8 *aString,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill) +/** +Appends data onto the end of this descriptor's data and justifies it. + +The source of the appended data is a memory location. + +The target area is considered to be an area of specified width, immediately +following this descriptor's existing data. Source data is copied into, and +aligned within, this target area according to the specified alignment instruction. + +If the length of the target area is larger than the length of the source, +then spare space within the target area is padded with the fill character. + +@param aString A pointer to a source memory location. + +@param aLength The length of data to be copied. If this is greater than the + width of the target area, then the length of data copied is + limited to the width. + +@param aWidth The width of the target area. If this has the specific + negative value KDefaultJustifyWidth, then the width is + re-set to the length of the data source. + +@param anAlignment The alignment of the data within the target area. + +@param aFill The fill character used to pad the target area. + +@panic USER 23 if the resulting length of this descriptor is greater than + its maximum length or aWidth has a negative value other + than KDefaultJustifyWidth. + +@panic USER 29 if aLength is negative. +*/ + { + + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8LengthNegative)); + if (aWidth==KDefaultJustifyWidth) + aWidth=aLength; + if (aLength>aWidth) + aLength=aWidth; + TInt offset=Length(); + AppendFill(aFill,aWidth); + TInt r=aWidth-aLength; + if (anAlignment==ECenter) + r>>=1; + else if (anAlignment==ELeft) + r=0; + memmove(WPtr()+offset+r,aString,aLength); + } +#endif // __KERNEL_MODE__ + +EXPORT_C void TDes8::Num(TInt64 aVal) +// +// Convert a TInt64 to the descriptor. +// +/** +Converts the 64-bit signed integer into a decimal character representation +and copies the conversion into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +If the integer is negative, the character representation is prefixed by a +minus sign. + +@param aVal The 64-bit signed integer value. +*/ + { + Zero(); + AppendNum(aVal); + } + +EXPORT_C void TDes8::Num(TUint64 aVal, TRadix aRadix) +/** +Converts the specified 64-bit unsigned integer into a character representation +based on the specified number system and copies the conversion into this descriptor, +replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +When a hexadecimal conversion is specified, hexadecimal characters are in +lower case. + +@param aVal The 64-bit integer value. This is treated as an unsigned value. +@param aRadix The number system representation for the 64-bit integer. +*/ + { + Zero(); + AppendNum(aVal, aRadix); + } + +EXPORT_C void TDes8::NumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth) +/** +Converts the specified unsigned integer into a fixed width character +representation based on the specified number system and copies the conversion +into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +The function generates the exact number of specified characters, either padding +to the left with character zeroes or discarding low order characters as necessary. + +When a hexadecimal conversion is specified, hexadecimal characters are in +lower case. + +This function is equivalent to using Format() with parameters which specify: + +1. a fixed length target field + +2. padding with zero characters, for example "%08x". + +When this is the case, always use NumFixedWidth() in preference +to Format() as it is more efficient. + +@param aVal The unsigned integer value. +@param aRadix The number system representation for the unsigned integer. +@param aWidth The number of characters: to be used to contain the conversion, + to be copied into this descriptor. + +@see TDes8::Format() +*/ + { + + Zero(); + AppendNumFixedWidth(aVal,aRadix,aWidth); + } + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::NumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth) +/** +Converts the specified unsigned integer into a fixed width character +representation based on the specified number system and copies the conversion +into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +The function generates the exact number of specified characters, either padding +to the left with character zeroes or discarding low order characters as +necessary. + +When a hexadecimal conversion is specified, hexadecimal characters are in +upper case. + +This function is equivalent to using Format() with parameters which specify: + +1. a fixed length target field + +2. padding with zero characters, for example "%08x". + +When this is the case, always use NumFixedWidthUC() in +preference to Format() as it is more efficient. + +@param aVal The unsigned integer value. +@param aRadix The number system representation for the unsigned integer. +@param aWidth The number of characters to be used to contain the conversion, + and to be copied into this descriptor. + +@see TDes8::Format() +*/ + { + + Zero(); + AppendNumFixedWidthUC(aVal,aRadix,aWidth); + } + +EXPORT_C void TDes8::NumUC(TUint64 aVal, TRadix aRadix) //NOT __KERNEL_MODE__ +/** +Converts the specified 64-bit unsigned integer into a character representation +based on the specified number system and copies the conversion into this descriptor, +replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +When a hexadecimal conversion is specified, hexadecimal characters are in +upper case. + +@param aVal The 64-bit integer value. This is treated as an unsigned value. +@param aRadix The number system representation for the 64-bit integer. If no + explicit value is specified, then EDecimal is the default. +*/ + { + Zero(); + AppendNumUC(aVal,aRadix); + } +#endif // __KERNEL_MODE__ + +EXPORT_C void TDes8::AppendNum(TInt64 aVal) +/** +Converts the 64-bit signed integer into a decimal character representation +and appends the conversion onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +If the integer is negative, the character representation is prefixed by a +minus sign. + +@param aVal The 64-bit signed integer value. +*/ + { + if (aVal < 0) + { + Append('-'); + aVal = -aVal; + } + + AppendNum(aVal, EDecimal); + } + +#ifndef __DES_MACHINE_CODED__ +GLDEF_C TInt __DoConvertNum(TUint aVal, TRadix aRadix, TUint aA, TUint8*& aDest) + { + __KERNEL_CHECK_RADIX(aRadix); + TUint radix = (TUint)aRadix; + TUint8* p = aDest; + TBool out16 = (aA>255); + aA &= 0xff; + do { + TUint q = aVal/radix; + TUint c = aVal-q*radix; + (c>9) ? c+=(aA-10) : c+='0'; + aVal = q; + if (out16) + *--p = 0; + *--p = (TUint8)c; + } while (aVal); + TInt l = aDest - p; + aDest = p; + return l; + } + +GLDEF_C TInt __DoConvertNum(TUint64 aVal, TRadix aRadix, TUint aA, TUint8*& aDest) + { + __KERNEL_CHECK_RADIX(aRadix); + TUint radix = (TUint)aRadix; + TUint8* p = aDest; + TBool out16 = (aA>255); + TUint8 a = static_cast(aA); + while (aVal >= UI64LIT(0x100000000)) + { + TUint8 c = static_cast(aVal % radix); + aVal /= radix; + (c > 9) ? c = static_cast(c + a - 10) : c = static_cast(c + '0'); + if (out16) + *--p = 0; + *--p = c; + } + TInt l = aDest - p; + aDest = p; + return l + __DoConvertNum((TUint)aVal, aRadix, aA, aDest); + } +#endif + +void TDes8::DoPadAppendNum(TInt l, TInt aW, const TUint8* p) + { + if (aW<=0) + { + Append(p, l); + return; + } + TInt l0 = Length(); + SetLength(l0 + aW); + TUint8* d = WPtr() + l0; + for (; aW>l; --aW) *d++ = (TUint8)'0'; + memcpy(d, p, aW); + } + +void TDes8::DoAppendNum(TUint64 aVal, TRadix aRadix, TUint aA, TInt aW) +// +// Convert a TUint64 into the descriptor. +// + { + TUint8 buf[APPEND_BUF_SIZE_64]; + TUint8* p = buf + APPEND_BUF_SIZE_64; + TInt l = __DoConvertNum(aVal, aRadix, aA, p); + // coverity[overrun-local] + DoPadAppendNum(l, aW, p); + } + +EXPORT_C void TDes8::AppendNum(TUint64 aVal, TRadix aRadix) +/** +Converts the specified 64-bit unsigned integer into a character representation +based on the specified number system and appends the conversion onto the end +of this descriptor's data. The length of this descriptor is incremented to +reflect the new content + +When a hexadecimal conversion is specified, hexadecimal characters are in +lower case. + +@param aVal The 64-bit integer value. This is treated as an unsigned value. +@param aRadix The number system representation for the 64-bit integer. +*/ + { + DoAppendNum(aVal, aRadix, 'a', 0); + } + +EXPORT_C void TDes8::AppendNumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth) +/** +Converts the specified unsigned integer into a fixed width character +representation based on the specified number system and appends the conversion +onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +The function generates the exact number of specified characters, either padding +to the left with character zeroes or discarding low order characters as +necessary. + +When a hexadecimal conversion is specified, hexadecimal characters are in +lower case. + +@param aVal The unsigned integer value. +@param aRadix The number system representation for the unsigned integer. +@param aWidth The number of characters to be used to contain the conversion, + and to be appended to this descriptor. +*/ + { + DoAppendNum(aVal, aRadix, 'a', aWidth); + } + +#if (!defined(__DES8_MACHINE_CODED__) && !defined(__KERNEL_MODE__)) +EXPORT_C TPtr8 TDes8::LeftTPtr(TInt aLength) const +/** +Extracts the leftmost part of the data. + +The function does not cut or remove any data but constructs a modifiable +pointer descriptor to represent the leftmost part of the data. + +@param aLength The length of the data to be extracted. If this value + is greater than the length of the descriptor, the function + extracts the whole of the descriptor. + +@return The 8-bit modifiable pointer descriptor representing the leftmost + part of the data. + +@panic USER 22 if aLength is negative. +*/ + { + + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8PosOutOfRange)); + TInt len=Min(aLength,Length()); + return(TPtr8((TUint8*)Ptr(),len,len)); + } + +EXPORT_C TPtr8 TDes8::RightTPtr(TInt aLength) const +/** +Extracts the rightmost part of the data. + +The function does not cut or remove any data but constructs a modifiable +pointer descriptor to represent the rightmost part of the data. + +@param aLength The length of data to be extracted. If this value + is greater than the length of the descriptor, the function + extracts the whole of the descriptor. + +@return The 8 bit modifiable pointer descriptor representing the rightmost + part of the data. + +@panic USER 22 if aLength is negative. +*/ + { + + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8PosOutOfRange)); + TInt len=Length(); + if (aLength>len) + aLength=len; + return(TPtr8((TUint8*)Ptr()+len-aLength,aLength,aLength)); + } + +EXPORT_C TPtr8 TDes8::MidTPtr(TInt aPos) const +/** +Extracts a portion of the data. + +The function does not cut or remove any data but constructs a modifiable +pointer descriptor to represent the defined portion. + +The portion is identified by its starting position and by the length of the +remainder of the data starting from the specified position. + +@param aPos The starting position of the data to be extracted. This is an + offset value; a zero value refers to the leftmost data position. + +@return The 8-bit modifiable pointer descriptor representing the specified + portion of the data. + +@panic USER 22 if aPos is negative or aPos is greater than the + length of the descriptor. +*/ + { + + TInt len=Length(); + __ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange)); + return(TPtr8((TUint8*)Ptr()+aPos,len-aPos,len-aPos)); + } + +EXPORT_C TPtr8 TDes8::MidTPtr(TInt aPos,TInt aLength) const +/** +Extracts a portion of the data. + +The function does not cut or remove any data but constructs a modifiable +pointer descriptor to represent the defined portion. + +The portion is identified by its starting position and by its length. + +@param aPos The starting position of the data to be extracted. This is an + offset value; a zero value refers to the leftmost data position. +@param aLength The length of data to be extracted. + +@return The 8 bit modifiable pointer descriptor representing the specified + portion of the data. + +@panic USER 22 if aPos is negative or aPos plus aLength is greater than the + length of the descriptor. +*/ + { + + __ASSERT_ALWAYS(aPos>=0 && (aPos+aLength)<=Length(),Panic(ETDes8PosOutOfRange)); + return(TPtr8((TUint8*)Ptr()+aPos,aLength,aLength)); + } +#endif + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDes8::AppendNumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth) +/** +Converts the specified unsigned integer into a fixed width character +representation based on the specified number system and appends the conversion +onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +The function generates the exact number of specified characters, either +padding to the left with character zeroes or discarding low order characters +as necessary. + +When a hexadecimal conversion is specified, hexadecimal characters are in +upper case. + +@param aVal The unsigned integer value. +@param aRadix The number system representation for the unsigned integer. +@param aWidth The number of characters to be used to contain the conversion, + and to be appended to this descriptor. +*/ + { + DoAppendNum(aVal, aRadix, 'A', aWidth); + } + +EXPORT_C void TDes8::AppendNumUC(TUint64 aVal, TRadix aRadix) +/** Converts the specified 64-bit unsigned integer into a character +representation based on the specified number system and appends the conversion +onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +When a hexadecimal conversion is specified, hexadecimal characters are in +upper case. + +@param aVal The 64-bit integer value. This is treated as an unsigned value. +@param aRadix The number system representation for the 64-bit integer. If no + explicit value is specified, then EDecimal is the default. +*/ + { + DoAppendNum(aVal, aRadix, 'A', 0); + } + +EXPORT_C void TDes8::Format(TRefByValue aFmt,...) +/** +Formats and copies text into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +The function takes a format string and a variable number of arguments. +The format string contains literal text embedded with directives for converting +the trailing list of arguments into text. + +The embedded directives are character sequences prefixed with the '%' character. +The literal text is simply copied into this descriptor unaltered while +the '%' directives are used to convert successive arguments from the +trailing list. + +The resulting stream of literal text and converted arguments is copied into +this descriptor. + +The syntax of the embedded directives follows one of four general patterns. + +Note that formatting of single numerical values can be achieved more +conveniently using the Num() and NumUC() member functions of this class. + +The full description of the syntax of a format string cannot be included here. +For full details, navigate to the Symbian OS guide, and follow the hierarchy of links: + +@code +Symbian OS Guide + Base + Using User Library (E32) + Buffers and Strings + Using Descriptors + How to Use Descriptors + Format string syntax +@endcode + +@param aFmt The descriptor containing the format string. + The TRefByValue class provides a constructor which takes a + TDesC8 type. + +@param ... A variable number of arguments to be converted to text as + dictated by the format string. + +@panic USER 23 if the resulting length of text in this descriptor exceeds + the descriptor's maximum length. +@panic USER 24 if the format string has incorrect syntax. + +@see TDes8::Num() +@see TDes8::NumUC() +*/ + { + + VA_LIST list; + VA_START(list,aFmt); + // coverity[uninit_use_in_call] + FormatList(aFmt,list); + } + +EXPORT_C void TDes8::FormatList(const TDesC8 &aFmt,VA_LIST aList) +/** +Formats and copies text into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +The behaviour of this function is the same as Format(). In practice, it is +better and easier to use Format(), passing a variable number of arguments +as required by the format string. + +@param aFmt The descriptor containing the format string. +@param aList A pointer to an argument list. + +@see TDes8::Format() +@see VA_LIST +*/ + { + + Zero(); + AppendFormatList(aFmt,aList); + } + +EXPORT_C void TDes8::AppendFormat(TRefByValue aFmt,TDes8Overflow *aOverflowHandler,...) +/** +Formats and appends text onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +The function takes a format string and a variable number of arguments. +The format string contains literal text, embedded with directives, +for converting the trailing list of arguments into text. + +The embedded directives are character sequences prefixed with the '%' character. +The literal text is simply copied into this descriptor unaltered while +the '%' directives are used to convert successive arguments from the +trailing list. See the description of the Format() function. + +Literal text is appended on a character by character basis. +If it results in the length of this descriptor exceeding its maximum length, +then the function: + +1. calls the Overflow() member function of the overflow handler, if an overflow + handler is supplied +2 raises a USER 23 panic, if no overflow handler is supplied. + +As much literal text as possible will have been copied into this descriptor +and this descriptor will have reached its maximum length. + +Text converted from a trailing argument is appended as a complete string. +If an attempt to append this string fails because the resulting length +of this descriptor would exceed its maximum length, then the function: + +1. calls the Overflow() member function of the overflow handler, if an overflow + handler is supplied + +2 raises a USER 23 panic, if no overflow handler is supplied. + +None of the generated text is appended and length of this descriptor +may be less than the maximum. + +@param aFmt The 8-bit non-modifiable descriptor containing the + format string. The TRefByValue class provides a + constructor which takes a TDesC8 type. + +@param aOverflowHandler A pointer to the overflow handler. + +@param ... A variable number of arguments to be converted to text + as dictated by the format string. + +@panic USER 23 if the length of the descriptor exceeds its maximum length and + no overflow handler has been supplied. +@panic USER 24 if the format string has incorrect syntax. + +@see TDes8::Format() +@see TDes8Overflow::Overflow() +*/ + { + + VA_LIST list; + VA_START(list, aOverflowHandler); + // coverity[uninit_use_in_call] + AppendFormatList(aFmt,list,aOverflowHandler); + } + +EXPORT_C void TDes8::AppendFormat(TRefByValue aFmt,...) +/** +Formats and appends text onto the end of this descriptor's data. + +The length of this descriptor is incremented to reflect the new content. + +The function takes a format string and a variable number of arguments. +The format string contains literal text, embedded with directives, +for converting the trailing list of arguments into text. + +The embedded directives are character sequences prefixed with the '%' character. +The literal text is simply copied into this descriptor unaltered while +the '%' directives are used to convert successive arguments from the +trailing list. See the description of the Format() function. + +Literal text is appended on a character by character basis. + +Text converted from a trailing argument is appended as a complete string. + +@param aFmt The 8-bit non-modifiable descriptor containing the + format string. The TRefByValue class provides a + constructor which takes a TDesC8 type. + +@param ... A variable number of arguments to be converted to text + as dictated by the format string. + + +@panic USER 23 if the resulting length of text in this descriptor exceeds + the descriptor's maximum length. +@panic USER 24 if the format string has incorrect syntax. + +@see TDes8::Format() +*/ + { + + VA_LIST list; + VA_START(list,aFmt); + AppendFormatList(aFmt,list); + } +#endif // __KERNEL_MODE__ + +#if !defined(__DES8_MACHINE_CODED__) | defined(__EABI_CTORS__) +EXPORT_C TPtrC8::TPtrC8() + : TDesC8(EPtrC,0),iPtr(0) +/** +Default constructor. + +Constructs an empty 8-bit non-modifiable pointer descriptor. + +It represents no data and its length is zero. + +The non-modifiable pointer descriptor can, subsequently, be set to represent +data. + +@see TPtrC8::Set() +*/ + {} + +EXPORT_C TPtrC8::TPtrC8(const TDesC8 &aDes) + : TDesC8(EPtrC,aDes.Length()),iPtr(aDes.Ptr()) +/** +Constructs the 8-bit non-modifiable pointer descriptor from any existing +descriptor. + +It is set to point to the same data and is given the same length as the source +descriptor. + +@param aDes A reference to an 8bit non-modifiable descriptor. +*/ + {} + +EXPORT_C TPtrC8::TPtrC8(const TUint8 *aString) + : TDesC8(EPtrC,STRING_LENGTH(aString)),iPtr(aString) +/** +Constructs the 8-bit non-modifiable pointer descriptor to point to a zero +terminated string, whether in RAM or ROM. + +The length of the descriptor is set to the length of the zero terminated +string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. +*/ + {} + +EXPORT_C TPtrC8::TPtrC8(const TUint8 *aBuf,TInt aLength) + : TDesC8(EPtrC,aLength),iPtr(aBuf) +/** +Constructs 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. +*/ + { + __ASSERT_ALWAYS(aLength>=0,Panic(ETDes8LengthNegative)); + } + +EXPORT_C TPtr8::TPtr8(TUint8 *aBuf,TInt aMaxLength) + : TDes8(EPtr,0,aMaxLength),iPtr(aBuf) +/** +Constructs the 8-bit modifiable pointer descriptor to point to the specified +location in memory, whether in RAM or ROM. + +The length of the descriptor is set to zero and its maximum length is set +to the specified value. + +@param aBuf A pointer to the location that the descriptor is to + represent. + +@param aMaxLength The maximum length of the descriptor. + +@panic USER 30 if aMaxLength is negative. +*/ + { + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + } + +EXPORT_C TPtr8::TPtr8(TUint8 *aBuf,TInt aLength,TInt aMaxLength) + : TDes8(EPtr,aLength,aMaxLength),iPtr(aBuf) +/** +Constructs 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 descriptor's + maximum length, +@panic USER 30 if aMaxLength is negative. +*/ + { + __ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + __ASSERT_ALWAYS(TUint(aLength)<=TUint(aMaxLength),Panic(ETDes8LengthOutOfRange)); + } + +EXPORT_C TPtr8::TPtr8(TBufCBase8 &aLcb,TInt aMaxLength) + : TDes8(EBufCPtr,aLcb.Length(),aMaxLength),iPtr((TUint8*)&aLcb) + { + __ASSERT_DEBUG(aLcb.Length()<=aMaxLength,Panic(ETDes8LengthOutOfRange)); + } + +EXPORT_C TBufBase8::TBufBase8(TInt aMaxLength) + :TDes8(EBuf,0,aMaxLength) + { + __ASSERT_DEBUG(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + } + +EXPORT_C TBufBase8::TBufBase8(TInt aLength,TInt aMaxLength) + :TDes8(EBuf,aLength,aMaxLength) + { + __ASSERT_DEBUG(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + __ASSERT_ALWAYS(TUint(aLength)<=TUint(aMaxLength),Panic(ETDes8LengthOutOfRange)); + } + +EXPORT_C TBufBase8::TBufBase8(const TUint8* aString,TInt aMaxLength) + :TDes8(EBuf,0,aMaxLength) + { + __ASSERT_DEBUG(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + Copy(aString); + } + +EXPORT_C TBufBase8::TBufBase8(const TDesC8& aDes,TInt aMaxLength) + :TDes8(EBuf,0,aMaxLength) + { + __ASSERT_DEBUG(aMaxLength>=0,Panic(ETDes8MaxLengthNegative)); + Copy(aDes); + } + +#endif + +// Truncate literal string to fit into descriptor +EXPORT_C void TDes8IgnoreOverflow::Overflow(TDes8& /*aDes*/) + {} + +#ifndef __KERNEL_MODE__ +EXPORT_C void TDesC8::__DbgTestInvariant() const +// +// Test that the class obeys its invariant. +// + { + +#if defined(_DEBUG) + switch (Type()) + { + case EBufC: + case EPtrC: + case EPtr: + case EBuf: + case EBufCPtr: + break; + default: + User::Invariant(); + } +#endif + } + +EXPORT_C void TPtrC8::__DbgTestInvariant() const +// +// Test that the class obeys its invariant. +// + { + +#if defined(_DEBUG) + TDesC8::__DbgTestInvariant(); // Test base class + if (Type()!=EPtrC) + User::Invariant(); +#endif + } + +EXPORT_C void TDes8::__DbgTestInvariant() const +// +// Test that the class obeys its invariant. +// + { + +#if defined(_DEBUG) + TDesC8::__DbgTestInvariant(); // Test base class + if (Length()>MaxLength() || !(Type()==EPtr || Type()==EBufCPtr || Type()==EBuf)) + User::Invariant(); +#endif + } + +EXPORT_C void HBufC8::__DbgTestInvariant() const +// +// Test that the class obeys its invariant. +// + { + +#if defined(_DEBUG) + TDesC8::__DbgTestInvariant(); // Test base class + if (Length()>(TInt)(User::AllocLen(this)-sizeof(TDesC8)) || Type()!=EBufC) + User::Invariant(); +#endif + } + +EXPORT_C void TPtr8::__DbgTestInvariant() const +// +// Test that the class obeys its invariant. +// + { + +#if defined(_DEBUG) + TDes8::__DbgTestInvariant(); // Test base class + if (!(Type()==EPtr || Type()==EBufCPtr)) + User::Invariant(); +#endif + } + +/** Expand all characters from 8 to 16 bits + +@return 16-bit pointer descriptor to transformed text + +The length of descriptor increased by 2 (length *= 2). + +@panic USER 187 if either the descriptor length or the maximum length is odd +or data pointer is not aligned by 2-bytes boundary +*/ +EXPORT_C TPtr16 TDes8::Expand() + { + TInt l = Length(); + TInt ml = MaxLength(); + const TText8* s0 = Ptr(); + const TText8* s = s0 + l; + __ASSERT_ALWAYS( !((ml|(TInt)s0)&1), Panic(EDes8ExpandOdd) ); + SetLength(l<<1); + TText16* d = ((TText16*)s0) + l; + while (s > s0) + *--d = *--s; + return TPtr16(d, l, ml>>1); + } + + +/** Collapse all characters from 16 to 8 bits + +The length of descriptor truncated by 2 (length /= 2). + +@panic USER 188 if either the descriptor length or the maximum length is odd +or data pointer is not aligned by 2-bytes boundary. +*/ + +EXPORT_C void TDes8::Collapse() + { + TInt l = Length(); + TInt ml = MaxLength(); + TText8* d = (TText8*)Ptr(); + __ASSERT_ALWAYS( !((l|ml|(TInt)d)&1), Panic(EDes8CollapseOdd) ); + const TText16* s = (const TText16*)d; + const TText16* sE = s + (l>>1); + while (s < sE) + *d++ = (TText8)*s++; + SetLength(l>>1); + } +#else // __KERNEL_MODE__ + +EXPORT_C TInt TDesC8::CompareF(const TDesC8 &aDes) const +/** +Compares this descriptor's folded data with the specified descriptor's folded +data. + +Note that folding is locale-independent behaviour. It is also important to +note that there can be no guarantee that folding is in any way culturally +appropriate, and should not be used for comparing strings in natural language; +use CompareC() for this. + +@param aDes The 8-bit non modifable descriptor whose data is to be compared + with this descriptor's data. + +@return Positive, if this descriptor is greater than the specified descriptor. + Negative, if this descriptor is less than the specified descriptor. + Zero, if both descriptors have the same length and the their contents + are the same. + +@see TDesC8::Compare() +*/ + { + + TInt ll = Length(); + TInt rl = aDes.Length(); + TInt r = memicmp(Ptr(), aDes.Ptr(), Min(ll, rl)); + if (r == 0) + r = ll - rl; + return r; + } + +#endif // __KERNEL_MODE__ + +#ifndef __KERNEL_MODE__ + +/** +Default constructor. + +Constructs a zero-length 8-bit resizable buffer descriptor. + +Note that the object owns no allocated memory. +*/ +EXPORT_C RBuf8::RBuf8() + :TDes8(EPtr,0,0),iEPtrType(NULL) + { + // Zero-length RBuf8 is of type EPtr with NULL pointer. + } + + + + +/** +Constructor. + +Constructs an 8-bit resizable buffer descriptor, transferring ownership of the +specified heap descriptor to this object. + +@param aHBuf The heap descriptor to be transferred to this object. This pointer + can be NULL, which means that a zero length 8-bit resizable + buffer descriptor is constructed, and the object will not own any + allocated memory. +*/ +EXPORT_C RBuf8::RBuf8(HBufC8* aHBuf) + { + if(aHBuf) + //Create EBufCPtr type descriptor that points to aHBuf + new(this) TPtr8(aHBuf->Des()); + else + //Create zero-length RBuf8. It is EPtr type of descriptor that points to NULL. + new(this) RBuf8(); + } + + + + +/** +Protected constructor. +*/ +EXPORT_C RBuf8::RBuf8(TInt aType,TInt aLength,TInt aMaxLength) + :TDes8(aType,aLength,aMaxLength) + { + } + + + + +/** +Transfers ownership of the specified 8-bit resizable buffer descriptor's +buffer to this object. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aRBuf The source 8-bit resizable buffer. The ownership of this + object's buffer is to be transferred. + +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::Assign(const RBuf8& aRBuf) + { + Mem::Copy(this, &aRBuf, sizeof(RBuf8)); + __TEST_INVARIANT; + } + + + + +/** +Assigns ownership of the specified allocated memory to this object. + +The allocated memory forms the buffer for this descriptor. The current length +of the descriptor is set to zero. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aHeapCell The allocated memory to be assigned to this object. This + pointer can be NULL, which means that a zero length 8-bit + resizable buffer descriptor is created. +@param aMaxLength The maximum length of the descriptor. + +@panic USER 20 If the specified maximum length is greater then the size of + the allocated heap cell, or the specified maximum length + is NOT zero when the pointer to the heap cell is NULL. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::Assign(TUint8 *aHeapCell,TInt aMaxLength) + { + Assign(aHeapCell,0,aMaxLength); + } + + + + +/** +Assigns ownership of the specified allocated memory to this object. + +The allocated memory forms the buffer for this descriptor. The current length +of the descriptor is set to the value of the second parameter. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aHeapCell The allocated memory to be assigned to this object. +@param aLength The length of the descriptor. +@param aMaxLength The maximum length of the descriptor. + +@panic USER 20 If the specified maximum length is greater then the size of + the allocated heap cell, or the specified length is greater then + the specified maximum length, or the specified maximum length + is NOT zero when the pointer to the heap cell is NULL. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::Assign(TUint8 *aHeapCell,TInt aLength,TInt aMaxLength) + { + __ASSERT_ALWAYS(aLength<=aMaxLength, Panic(ETDes8LengthOutOfRange)); + if(aHeapCell) + { + __ASSERT_ALWAYS(User::AllocLen(aHeapCell) >= aMaxLength * (TInt)sizeof(TUint8), Panic(ETDes8LengthOutOfRange)); + //Create EPtr type descriptor that points to aHeapCell + new(this) TPtr8(aHeapCell,aLength,aMaxLength); + } + else + { + __ASSERT_ALWAYS(aMaxLength == 0, Panic(ETDes8LengthOutOfRange)); + //Create zero-length RBuf. It is EPtr type of descriptor that points to NULL. + new(this) RBuf8(); + } + __TEST_INVARIANT; + } + + + + +/** +Transfers ownership of the specified heap descriptor to this object. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aHBuf The heap descriptor to be transferred to this object. + This pointer can be NULL, which means that a zero length + 8-bit resizable buffer descriptor is created. +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::Assign(HBufC8* aHBuf) + { + new(this) RBuf8(aHBuf); + } + + + + +/** +Swaps the content of two 8-bit resizable buffer descriptors. + +@param aRBuf The 8-bit resizable buffer descriptor whose contents are to be + swapped with this one. +*/ +EXPORT_C void RBuf8::Swap(RBuf8& aRBuf) + { + Mem::Swap(this,&aRBuf,sizeof(*this)); + } + + + + +/** +Creates an 8-bit resizable buffer descriptor. + +The function allocates sufficient memory to contain descriptor data up to +the specified maximum length. + +The current length of the descriptor is set to zero. The maximum length of +the descriptor is set to the specified value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aMaxLength The maximum length of the descriptor. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see RBuf8::Close() +*/ +EXPORT_C TInt RBuf8::Create(TInt aMaxLength) + { + if (aMaxLength) + { + //Allocate memory + TUint8* buf=(TUint8*)User::Alloc(aMaxLength*sizeof(TUint8)); + if(!buf) return KErrNoMemory; + iEPtrType = buf; + } + else + iEPtrType = NULL; //Zero-length descriptor. + + + //Create EPtr type descriptor. + new(this) RBuf8(EPtr,0,aMaxLength); + __TEST_INVARIANT; + return KErrNone; + } + + + + +/** +Creates an 8-bit resizable buffer descriptor, and leaves on failure. + +The function allocates sufficient memory to contain descriptor data up to +the specified maximum length. + +The current length of the descriptor is set to zero. The maximum length of +the descriptor is set to the specified value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aMaxLength The length and the maximum length of the descriptor. + +@leave KErrNoMemory If there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::CreateL(TInt aMaxLength) + { + User::LeaveIfError(Create(aMaxLength)); + } + + + + +/** +Creates an 8-bit resizable buffer descriptor. + +The function allocates sufficient memory to contain descriptor data up to +the specified maximum length. + +Both the current length and the maximum length of the descriptor are set to +the specified value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aMaxLength The length and the maximum length of the descriptor. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@see RBuf8::Close() +*/ +EXPORT_C TInt RBuf8::CreateMax(TInt aMaxLength) + { + TInt err=Create(aMaxLength); + if(err==KErrNone) + SetMax(); + return err; + } + + + + +/** +Creates an 8-bit resizable buffer descriptor, and leaves on failure. + +The function allocates sufficient memory to contain descriptor data up to +the specified maximum length. + +Both the current length and the maximum length of the descriptor are set to +the specified value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aMaxLength The length and the maximum length of the descriptor. + +@leave KErrNoMemory If there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::CreateMaxL(TInt aMaxLength) + { + User::LeaveIfError(CreateMax(aMaxLength)); + } + + + + +/** +Creates a 8-bit resizable buffer descriptor to contain a copy of the +specified (source) descriptor. + +The function allocates sufficient memory so that this descriptor's maximum +length is the same as the length of the source descriptor. Both the current +length and the maximum length of this descriptor are set to +the length of the source descriptor. + +The data contained in the source descriptor is copied into this +descriptor. + +Note that the function assumes that this descriptor does not +already own any allocated memory. It does not check, nor does it free any +pre-existing owned allocated memory. If this descriptor does already own +allocated memory, RBuf8::Close() should be invoked on this descriptor before +this function is invoked. + +@param aDes Source descriptor to be copied into this object. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see TDes8::Copy() +@see RBuf8::Close() +*/ +EXPORT_C TInt RBuf8::Create(const TDesC8& aDes) + { + return Create(aDes,aDes.Length()); + } + + + + +/** +Creates an 8-bit resizable buffer descriptor to contain a copy of the specified +(source) descriptor, and leaves on failure. + +The function allocates sufficient memory so that this descriptor's maximum +length is the same as the length of the source descriptor.Both the current +length and the maximum length of this descriptor are set to the length +of the source descriptor. + +The data contained in the source descriptor is copied into this descriptor. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any +pre-existing owned allocated memory. If this descriptor does already own +allocated memory, RBuf8::Close() should be invoked on this descriptor before +this function is invoked. + +@param aDes Source descriptor to be copied into this object. + +@leave KErrNoMemory If there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see TDes8::Copy() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::CreateL(const TDesC8& aDes) + { + CreateL(aDes,aDes.Length()); + } + + + + +/** +Creates an 8-bit resizable buffer descriptor to contain a copy of the +specified (source) descriptor. + +The function allocates sufficient memory so that this descriptor's maximum length +is the same as the value of the aMaxLength parameter. + +The data contained in the source descriptor is copied into this descriptor. +The length of data copied is either + +- the length of the source descriptor aDes + +or + +- the value of the aMaxLength parameter + +whichever is the smaller value. The current length of this descriptor is also +set to the smaller value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aDes Source descriptor to be copied into this object. + +@param aMaxLength The maximum length of this descriptor. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see TDes8::Copy() +@see RBuf8::Close() +*/ +EXPORT_C TInt RBuf8::Create(const TDesC8& aDes,TInt aMaxLength) + { + TInt err=Create(aMaxLength); + if(err==KErrNone) + Copy(aDes.Left(aMaxLength)); + return err; + } + + + + +/** +Creates an 8-bit resizable buffer descriptor to contain a copy of the specified +(source) descriptor, and leaves on failure. + +The function allocates sufficient memory so that this descriptor's maximum +length is the same as the value of the aMaxLength parameter. + +The data contained in the source descriptor is copied into this descriptor. +The length of data copied is either + +- the length of the source descriptor aDes + +or + +- the value of the aMaxLength parameter + +whichever is the smaller value. The current length of this descriptor is also +set to the smaller value. + +Note that the function assumes that this descriptor does not already own any +allocated memory. It does not check, nor does it free any pre-existing owned +allocated memory. If this descriptor does already own allocated memory, +RBuf8::Close() should be invoked on this descriptor before this function is +invoked. + +@param aDes Source descriptor to be copied into this object. + +@param aMaxLength The maximum length of this descriptor. + +@leave KErrNoMemory If there is insufficient memory. + +@see TDesC8::Length() +@see TDes8::MaxLength() +@see TDes8::Copy() +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::CreateL(const TDesC8& aDes,TInt aMaxLength) + { + CreateL(aMaxLength); + Copy(aDes.Left(aMaxLength)); + } + + + + +/** +Resizes this 8-bit resizable buffer descriptor. + +The length and contents of the descriptor are unchanged. + +If the buffer descriptor was created from a zero-length heap descriptor +HBufC, this method might leak memory (the heap descriptor is not freed). +It is possible to avoid this by calling the Close() method prior to ReAlloc(), +but this should be done only in this situation (otherwise the buffer contents +will be lost). + +For example, add +@code + if (desc.MaxLength() == 0) desc.Close(); +@endcode +before the call to ReAlloc(). + +@param aMaxLength The new maximum length of the descriptor. This can be zero, + which results in a descriptor with zero maximum length and no + allocated memory. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@panic USER 26 If the new maximum length is less then the current descriptor length. +*/ +EXPORT_C TInt RBuf8::ReAlloc(TInt aMaxLength) + { + __ASSERT_ALWAYS(Length()<=aMaxLength, Panic(ETDes8ReAllocTooSmall)); + __TEST_INVARIANT; + + if (!aMaxLength) //Reallocation to zero length + { + User::Free(iEPtrType); //Free memory + new (this) RBuf8(); //Create zero-length RBuf + return KErrNone; + } + + if (!iMaxLength) //Reallocation from zero length + return Create(aMaxLength); + + switch(Type()) + { + case EPtr: + { + TUint8* buf = (TUint8*)User::ReAlloc(iEPtrType,aMaxLength*sizeof(TUint8)); + if(!buf) return KErrNoMemory; + iEPtrType = buf; + iMaxLength = aMaxLength; + break; + } + case EBufCPtr: + { + HBufC8* hbufc = iEBufCPtrType->ReAlloc(aMaxLength); + if(!hbufc) return KErrNoMemory; + Assign(hbufc); + break; + } + } + + __TEST_INVARIANT; + return KErrNone; + } + + + + +/** +Resizes this 8-bit resizable buffer descriptor, leaving on failure. + +The length and contents of the descriptor are unchanged. + +If the buffer descriptor was created from a zero-length heap descriptor +HBufC, this method might leak memory (the heap descriptor is not freed). +It is possible to avoid this by calling the Close() method prior to ReAllocL(), +but this should be done only in this situation (otherwise the buffer contents +will be lost). + +For example, add +@code + if (desc.MaxLength() == 0) desc.Close(); +@endcode +before the call to ReAlloc(). + +@param aMaxLength The new maximum length of the descriptor. This can be zero, + which results in a descriptor with zero maximum length and no + allocated memory. + +@return KErrNone, if successful; KErrNoMemory, if there is insufficient memory. + +@panic USER 26 If the new maximum length is less then the current descriptor length. +*/ +EXPORT_C void RBuf8::ReAllocL(TInt aMaxLength) + { + User::LeaveIfError(ReAlloc(aMaxLength)); + } + + + + +/** +Deallocates memory assigned to this object, and re-initializes the object as +a zero-length descriptor. +*/ +EXPORT_C void RBuf8::Close() + { + User::Free(iEPtrType); + //Create zero-length RBuf. It is EPtr type of descriptor that points to NULL. + new(this) RBuf8(); + } + + + + +/** +Pushes a cleanup item for this object onto the cleanup stack. + +The effect of this is to cause Close() to be called on this 8-bit resizable +buffer descriptor, when CleanupStack::PopAndDestroy() is called at some later time. + +@code +... +RBuf8 x; +.... +x.CleanupClosePushL(); +... +CleanupStack::PopAndDestroy(); +... +@endcode + +@see RBuf8::Close() +*/ +EXPORT_C void RBuf8::CleanupClosePushL() + { + ::CleanupClosePushL(*this); + } + + + + +/** +Tests that the class obeys its invariant. +*/ +EXPORT_C void RBuf8::__DbgTestInvariant() const + { +#ifdef _DEBUG + TDes8::__DbgTestInvariant(); + switch(Type()) + { + case EPtr: + if (iEPtrType) + { + __ASSERT_DEBUG(User::AllocLen(iEPtrType) >= iMaxLength*(TInt)sizeof(TUint8), Panic(EInvariantFalse)); + } + break; + case EBufCPtr: + iEBufCPtrType->__DbgTestInvariant(); + __ASSERT_DEBUG(iEBufCPtrType->Des().MaxLength() == iMaxLength, Panic(EInvariantFalse)); + __ASSERT_DEBUG(iEBufCPtrType->Length() == Length(), Panic(EInvariantFalse)); + break; + default: + User::Invariant(); + } +#endif // _DEBUG + } + +#endif // __KERNEL_MODE__ + + +#if defined(__DES8_MACHINE_CODED__) || defined(__EABI__) +GLDEF_C void Des8PanicBadDesType() + { + Panic(ETDes8BadDescriptorType); + } + +GLDEF_C void Des8PanicPosOutOfRange() + { + Panic(ETDes8PosOutOfRange); + } +#endif + +#ifdef __DES8_MACHINE_CODED__ +GLDEF_C void Des8PanicLengthNegative() + { + Panic(ETDes8LengthNegative); + } + +GLDEF_C void Des8PanicMaxLengthNegative() + { + Panic(ETDes8MaxLengthNegative); + } + +GLDEF_C void Des8PanicLengthOutOfRange() + { + Panic(ETDes8LengthOutOfRange); + } + +GLDEF_C void Des8PanicDesOverflow() + { + Panic(ETDes8Overflow); + } + +GLDEF_C void Des8PanicDesIndexOutOfRange() + { + Panic(ETDes8IndexOutOfRange); + } +#endif +