diff -r c55016431358 -r 0a7b44b10206 symport/e32/include/e32des8.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symport/e32/include/e32des8.h Thu Jun 25 15:59:54 2009 +0100 @@ -0,0 +1,693 @@ +// Copyright (c) 1995-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 "Symbian Foundation License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// e32\include\e32des8.h +// +// + +#ifndef __E32DES8_H__ +#define __E32DES8_H__ + +/** +@internalComponent +*/ +const TUint KMaskDesLength8=0xfffffff; + +class TBufCBase8; +class TDes8; +class TPtrC8; +class TPtr8; +class TPtr16; +#ifndef __KERNEL_MODE__ +class HBufC8; +#endif +class TDesC8 +/** +@publishedAll +@released + +Abstract base class for 8-bit non-modifiable descriptors. + +The class encapsulates the data member containing the length of data +represented by an 8-bit descriptor. It also provides member functions through +which the data can be accessed, but not modified. + +Data represented by this class is treated as a contiguous set of 8-bit (i.e. +single byte) values or data items. + +This class cannot be instantiated as it is intended to form part of a class +hierarchy; it provides a well defined part of descriptor behaviour. It can, +however, be passed as an argument type for functions which want access to +descriptor data but do not need to modify that data. + +@see TDesC +@see TPtrC8 +*/ + { +public: + inline TBool operator<(const TDesC8 &aDes) const; + inline TBool operator<=(const TDesC8 &aDes) const; + inline TBool operator>(const TDesC8 &aDes) const; + inline TBool operator>=(const TDesC8 &aDes) const; + inline TBool operator==(const TDesC8 &aDes) const; + inline TBool operator!=(const TDesC8 &aDes) const; + inline const TUint8 &operator[](TInt anIndex) const; + inline TInt Length() const; + inline TInt Size() const; + IMPORT_C const TUint8 *Ptr() const; + IMPORT_C TInt Compare(const TDesC8 &aDes) const; + IMPORT_C TInt Match(const TDesC8 &aDes) const; + IMPORT_C TInt MatchF(const TDesC8 &aDes) const; + IMPORT_C TInt MatchC(const TDesC8 &aDes) const; + IMPORT_C TInt Locate(TChar aChar) const; + IMPORT_C TInt LocateReverse(TChar aChar) const; + IMPORT_C TInt Find(const TDesC8 &aDes) const; + IMPORT_C TInt Find(const TUint8 *pS,TInt aLenS) const; + IMPORT_C TPtrC8 Left(TInt aLength) const; + IMPORT_C TPtrC8 Right(TInt aLength) const; + IMPORT_C TPtrC8 Mid(TInt aPos) const; + IMPORT_C TPtrC8 Mid(TInt aPos,TInt aLength) const; + IMPORT_C TInt CompareF(const TDesC8 &aDes) const; +#ifndef __KERNEL_MODE__ + IMPORT_C TInt CompareC(const TDesC8 &aDes) const; + IMPORT_C TInt LocateF(TChar aChar) const; + IMPORT_C TInt LocateReverseF(TChar aChar) const; + IMPORT_C TInt FindF(const TDesC8 &aDes) const; + IMPORT_C TInt FindF(const TUint8 *pS,TInt aLenS) const; + IMPORT_C TInt FindC(const TDesC8 &aDes) const; + IMPORT_C TInt FindC(const TUint8 *pS,TInt aLenS) const; + IMPORT_C HBufC8 *Alloc() const; + IMPORT_C HBufC8 *AllocL() const; + IMPORT_C HBufC8 *AllocLC() const; +#endif +protected: + inline TDesC8(TInt aType,TInt aLength); + inline TDesC8() {} +// delay this for a while +#ifdef SYMBIAN_FIX_TDESC_CONSTRUCTORS + inline TDesC8( const TDesC8& aOther) : iLength(aOther.iLength) {} +#endif +// inline ~TDesC8() {} Commented out for the moment since it breaks code + inline TInt Type() const; + inline void DoSetLength(TInt aLength); + IMPORT_C const TUint8 &AtC(TInt anIndex) const; +private: + TUint iLength; + __DECLARE_TEST; + }; +// +class TPtrC8 : public TDesC8 +/** +@publishedAll +@released + +8-bit non-modifiable pointer descriptor. + +This is a descriptor class intended for instantiation and encapsulates a +pointer to the 8-bit data that it represents. The data can live in ROM or RAM +and this location is separate from the descriptor object itself. + +The data is intended to be accessed, but not changed, through this descriptor. +The base class provides the functions through which data is accessed. + +@see TPtr8 +@see TDesC8 +@see TDes8 +@see TBufC8 +@see TBuf8 +@see HBufC8 +*/ + { +public: + IMPORT_C TPtrC8(); + IMPORT_C TPtrC8(const TDesC8 &aDes); + IMPORT_C TPtrC8(const TUint8 *aString); + IMPORT_C TPtrC8(const TUint8 *aBuf,TInt aLength); + inline void Set(const TUint8 *aBuf,TInt aLength); + inline void Set(const TDesC8 &aDes); + inline void Set(const TPtrC8& aPtr); +private: + TPtrC8& operator=(const TPtrC8 &aDes); +protected: + const TUint8 *iPtr; +private: + __DECLARE_TEST; + }; +// +class TDes8Overflow +/** +@publishedAll +@released + +An interface that defines an overflow handler for an 8-bit descriptor. + +The interface encapsulates a function that is called when an attempt to append +formatted text fails because the descriptor is already at its maximum length. + +A derived class must provide an implementation for the Overflow() member +function. + +@see TDes8::AppendFormat +*/ + { +public: + /** + Handles the overflow. + + This function is called when the TDes8::AppendFormat() variant that takes + an overflow handler argument, fails. + + @param aDes The 8-bit modifiable descriptor whose overflow results in the + call to this overflow handler. + */ + virtual void Overflow(TDes8 &aDes)=0; + }; +// +class TDes8IgnoreOverflow : public TDes8Overflow +/** +@publishedAll +@released + +A derived class which provides an implementation for the Overflow() member function +where truncation is required. + +@see TDes16::AppendFormat +*/ + { +public: + /** + Handles the overflow. + + This function is called when the TDes8::AppendFormat() + variant that takes an overflow handler argument, fails. + + @param aDes The 8-bit modifiable descriptor whose overflow results in the + call to this overflow handler. + */ + IMPORT_C virtual void Overflow(TDes8 &aDes); + }; +// +class TDesC16; +class TRealFormat; +class TDes8 : public TDesC8 +/** +@publishedAll +@released + +Abstract base class for 8-bit modifiable descriptors. + +The class encapsulates the data member containing the maximum length of data +represented by an 8-bit descriptor. It also provides member functions through +which the data can be modified. + +The class adds to the behaviour provided by TDesC8. + +This class cannot be instantiated as it is intended to form part of a class +hierarchy; it provides a well defined part of descriptor behaviour. It can, +however, be passed as an argument type for functions which need to both modify +and access descriptor data. + +@see TDes +@see TDesC8 +@see TDesC16 +*/ + { +public: + inline TDes8& operator=(const TUint8 *aString); + inline TDes8& operator=(const TDesC8 &aDes); + inline TDes8& operator=(const TDes8 &aDes); + inline TInt MaxLength() const; + inline TInt MaxSize() const; + inline const TUint8 &operator[](TInt anIndex) const; + inline TUint8 &operator[](TInt anIndex); + inline TDes8 &operator+=(const TDesC8 &aDes); + IMPORT_C void Zero(); + IMPORT_C void SetLength(TInt aLength); + IMPORT_C void SetMax(); + IMPORT_C void Copy(const TDesC8 &aDes); + IMPORT_C void Copy(const TUint8 *aBuf,TInt aLength); + IMPORT_C void Copy(const TUint8 *aString); + IMPORT_C void Copy(const TDesC16 &aDes); + IMPORT_C void Append(TChar aChar); + IMPORT_C void Append(const TDesC8 &aDes); + IMPORT_C void Append(const TDesC16 &aDes); + IMPORT_C void Append(const TUint8 *aBuf,TInt aLength); + IMPORT_C void Fill(TChar aChar); + IMPORT_C void Fill(TChar aChar,TInt aLength); + IMPORT_C void FillZ(); + IMPORT_C void FillZ(TInt aLength); + IMPORT_C void Num(TInt64 aVal); + IMPORT_C void Num(TUint64 aVal, TRadix aRadix); + IMPORT_C void NumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth); + IMPORT_C void AppendNum(TInt64 aVal); + IMPORT_C void AppendNum(TUint64 aVal, TRadix aRadix); + IMPORT_C void AppendNumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth); +#ifndef __KERNEL_MODE__ + IMPORT_C TPtr8 LeftTPtr(TInt aLength) const; + IMPORT_C TPtr8 RightTPtr(TInt aLength) const; + IMPORT_C TPtr8 MidTPtr(TInt aPos) const; + IMPORT_C TPtr8 MidTPtr(TInt aPos,TInt aLength) const; + IMPORT_C const TUint8 *PtrZ(); + IMPORT_C void CopyF(const TDesC8 &aDes); + IMPORT_C void CopyC(const TDesC8 &aDes); + IMPORT_C void CopyLC(const TDesC8 &aDes); + IMPORT_C void CopyUC(const TDesC8 &aDes); + IMPORT_C void CopyCP(const TDesC8 &aDes); + IMPORT_C void Swap(TDes8 &aDes); + IMPORT_C void AppendFill(TChar aChar,TInt aLength); + IMPORT_C void ZeroTerminate(); + IMPORT_C void Fold(); + IMPORT_C void Collate(); + IMPORT_C void LowerCase(); + IMPORT_C void UpperCase(); + IMPORT_C void Capitalize(); + IMPORT_C void Repeat(const TUint8 *aBuf,TInt aLength); + IMPORT_C void Repeat(const TDesC8 &aDes); + IMPORT_C void Trim(); + IMPORT_C void TrimAll(); + IMPORT_C void TrimLeft(); + IMPORT_C void TrimRight(); + IMPORT_C void Insert(TInt aPos,const TDesC8 &aDes); + IMPORT_C void Delete(TInt aPos,TInt aLength); + IMPORT_C void Replace(TInt aPos,TInt aLength,const TDesC8 &aDes); + IMPORT_C void Justify(const TDesC8 &aDes,TInt aWidth,TAlign anAlignment,TChar aFill); + IMPORT_C void NumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth); + IMPORT_C void NumUC(TUint64 aVal, TRadix aRadix=EDecimal); + IMPORT_C TInt Num(TReal aVal,const TRealFormat &aFormat) __SOFTFP; + IMPORT_C void AppendNumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth); + IMPORT_C TInt AppendNum(TReal aVal,const TRealFormat &aFormat) __SOFTFP; + IMPORT_C void AppendNumUC(TUint64 aVal,TRadix aRadix=EDecimal); + IMPORT_C void Format(TRefByValue aFmt,...); + IMPORT_C void FormatList(const TDesC8 &aFmt,VA_LIST aList); + IMPORT_C void AppendJustify(const TDesC8 &Des,TInt aWidth,TAlign anAlignment,TChar aFill); + IMPORT_C void AppendJustify(const TDesC8 &Des,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill); + IMPORT_C void AppendJustify(const TUint8 *aString,TInt aWidth,TAlign anAlignment,TChar aFill); + IMPORT_C void AppendJustify(const TUint8 *aString,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill); + IMPORT_C void AppendFormat(TRefByValue aFmt,TDes8Overflow *aOverflowHandler,...); + IMPORT_C void AppendFormat(TRefByValue aFmt,...); + IMPORT_C void AppendFormatList(const TDesC8 &aFmt,VA_LIST aList,TDes8Overflow *aOverflowHandler=NULL); + IMPORT_C TPtr16 Expand(); + IMPORT_C void Collapse(); +#endif //__KERNEL_MODE__ +protected: + inline TDes8(TInt aType,TInt aLength,TInt aMaxLength); + inline TUint8 *WPtr() const; + inline TDes8() {} +// delay this for a while +#ifdef SYMBIAN_FIX_TDESC_CONSTRUCTORS + inline TDes8(const TDes8& aOther) : TDesC8(aOther), iMaxLength(aOther.iMaxLength) {} +#endif + void DoAppendNum(TUint64 aVal, TRadix aRadix, TUint aA, TInt aW); + void DoPadAppendNum(TInt aLength, TInt aW, const TUint8* aBuf); +protected: + TInt iMaxLength; + __DECLARE_TEST; + }; +// +class TPtr8 : public TDes8 +/** +@publishedAll +@released + +8-bit modifiable pointer descriptor. + +This is a descriptor class intended for instantiation and encapsulates a +pointer to the 8-bit data that it represents. The data can live in ROM or +RAM and this location is separate from the descriptor object itself. + +The data is intended to be accessed and modified through this descriptor. +The base classes provide the functions through which the data can be +manipulated. + +@see TPtr +@see TPtrC8 +@see TDesC8 +@see TDes8 +@see TBufC8 +@see TBuf8 +@see HBufC8 +*/ + { +public: + IMPORT_C TPtr8(TUint8 *aBuf,TInt aMaxLength); + IMPORT_C TPtr8(TUint8 *aBuf,TInt aLength,TInt aMaxLength); + inline TPtr8& operator=(const TUint8 *aString); + inline TPtr8& operator=(const TDesC8& aDes); + inline TPtr8& operator=(const TPtr8& aPtr); + inline void Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength); + inline void Set(const TPtr8 &aPtr); +private: + IMPORT_C TPtr8(TBufCBase8 &aLcb,TInt aMaxLength); +protected: + TUint8 *iPtr; +private: + friend class TBufCBase8; + __DECLARE_TEST; + }; +// +class TBufCBase8 : public TDesC8 +/** +@internalAll +*/ + { +protected: + IMPORT_C TBufCBase8(); + inline TBufCBase8(TInt aLength); + IMPORT_C TBufCBase8(const TUint8 *aString,TInt aMaxLength); + IMPORT_C TBufCBase8(const TDesC8 &aDes,TInt aMaxLength); + IMPORT_C void Copy(const TUint8 *aString,TInt aMaxLength); + IMPORT_C void Copy(const TDesC8 &aDes,TInt aMaxLength); + inline TPtr8 DoDes(TInt aMaxLength); + inline TUint8 *WPtr() const; + }; +// +#ifndef __KERNEL_MODE__ +class RReadStream; +class HBufC8 : public TBufCBase8 +/** +@publishedAll +@released + +8-bit heap descriptor. + +This is a descriptor class which provides a buffer of fixed length, allocated +on the heap, for containing and accessing data. + +The class is intended for instantiation. + +Heap descriptors have the important property that they can be made larger +or smaller, changing the size of the descriptor buffer. This is achieved by +reallocating the descriptor. Unlike the behaviour of dynamic buffers, +reallocation is not done automatically. + +Data is intended to be accessed, but not modified; however, it can be +completely replaced using the assignment operators of this class. The base +class (TDesC8) provides the functions through which the data is accessed. + +The descriptor is hosted by a heap cell, and the 8-bit data that the +descriptor represents is part of the descriptor object itself. The size of the +cell depends on the requested maximum length of the descriptor buffer when the +descriptor is created or re-allocated. + +It is important to note that the size of the allocated cell, and, therefore, +the resulting maximum length of the descriptor, may be larger than requested +due to the way memory is allocated in Symbian OS. The amount by which this +may be rounded up depends on the platform and build type. + +@see HBufC +@see TPtr8 +@see TDesC8 +*/ + { +public: + IMPORT_C static HBufC8 *New(TInt aMaxLength); + IMPORT_C static HBufC8 *NewL(TInt aMaxLength); + IMPORT_C static HBufC8 *NewLC(TInt aMaxLength); + IMPORT_C static HBufC8 *NewMax(TInt aMaxLength); + IMPORT_C static HBufC8 *NewMaxL(TInt aMaxLength); + IMPORT_C static HBufC8 *NewMaxLC(TInt aMaxLength); + IMPORT_C static HBufC8 *NewL(RReadStream &aStream,TInt aMaxLength); + IMPORT_C static HBufC8 *NewLC(RReadStream &aStream,TInt aMaxLength); + IMPORT_C HBufC8& operator=(const TUint8 *aString); + IMPORT_C HBufC8& operator=(const TDesC8 &aDes); + inline HBufC8& operator=(const HBufC8 &aLcb); + IMPORT_C HBufC8 *ReAlloc(TInt aMaxLength); + IMPORT_C HBufC8 *ReAllocL(TInt aMaxLength); + IMPORT_C TPtr8 Des(); +private: + inline HBufC8(TInt aLength); +private: + TText8 iBuf[1]; + __DECLARE_TEST; + }; +#endif +// +/** +@internalComponent +*/ +#define __Size8 (sizeof(TInt)/sizeof(TInt8)) +/** +@internalComponent +*/ +#define __Align8(s) ((((s)+__Size8-1)/__Size8)*__Size8) +// +template +class TBufC8 : public TBufCBase8 +/** +@publishedAll +@released + +8-bit non-modifiable buffer descriptor. + +This is a descriptor class which provides a buffer of fixed length for +containing and accessing TUint8 data. + +The class intended for instantiation. The 8-bit data that the descriptor +represents is part of the descriptor object itself. + +The class is templated, based on an integer value which defines the size of +the descriptor's data area. + +The data is intended to be accessed, but not modified; however, it can be +completely replaced using the assignment operators of this class. The base +class provides the functions through which the data is accessed. + +@see TBufC +@see TDesC8 +@see TPtr8 +@see TUint8 +*/ + { +public: + inline TBufC8(); + inline TBufC8(const TUint8 *aString); + inline TBufC8(const TDesC8 &aDes); + inline TBufC8 &operator=(const TUint8 *aString); + inline TBufC8 &operator=(const TDesC8 &aDes); + inline TPtr8 Des(); +protected: + TUint8 iBuf[__Align8(S)]; + }; +// +class TBufBase8 : public TDes8 +/** +@internalAll +*/ + { +protected: + IMPORT_C TBufBase8(TInt aMaxLength); + IMPORT_C TBufBase8(TInt aLength,TInt aMaxLength); + IMPORT_C TBufBase8(const TUint8* aString,TInt aMaxLength); + IMPORT_C TBufBase8(const TDesC8& aDes,TInt aMaxLength); + }; +// +template +class TBuf8 : public TBufBase8 +/** +@publishedAll +@released + +A descriptor class which provides a buffer of fixed length for +containing, accessing and manipulating TUint8 data. + +The class is intended for instantiation. The 8-bit data that the descriptor +represents is part of the descriptor object itself. + +The class is templated, based on an integer value which determines the size +of the data area which is created as part of the buffer descriptor object; +this is also the maximum length of the descriptor. + +The data is intended to be both accessed and modified. The base classes provide +the functions through which the data is accessed. + +@see TBuf +@see TDesC8 +@see TDes8 +@see TPtr8 +*/ + { +public: + inline TBuf8(); + inline explicit TBuf8(TInt aLength); + inline TBuf8(const TUint8* aString); + inline TBuf8(const TDesC8& aDes); + inline TBuf8& operator=(const TUint8* aString); + inline TBuf8& operator=(const TDesC8& aDes); + inline TBuf8& operator=(const TBuf8& aBuf); +protected: + TUint8 iBuf[__Align8(S)]; + }; + +// +template +class TAlignedBuf8 : public TBufBase8 +/** +@internalComponent + +A descriptor class functionally identical to TBuf8, the only +difference from it being that TAlignedBuf8's internal buffer +is guaranteed to be 64-bit aligned. + +At present this class is not intended for general use. It exists +solely to support TPckgBuf which derives from it. + +@see TBuf8 +@see TPckgBuf +*/ +{ +public: + inline TAlignedBuf8(); + inline explicit TAlignedBuf8(TInt aLength); + inline TAlignedBuf8(const TUint8* aString); + inline TAlignedBuf8(const TDesC8& aDes); + inline TAlignedBuf8& operator=(const TUint8* aString); + inline TAlignedBuf8& operator=(const TDesC8& aDes); + inline TAlignedBuf8& operator=(const TAlignedBuf8& aBuf); +protected: + union { + double only_here_to_force_8byte_alignment; + TUint8 iBuf[__Align8(S)]; + }; +}; + +#ifndef __KERNEL_MODE__ + +class RBuf8 : public TDes8 +/** +@publishedAll +@released + +8 bit resizable buffer descriptor. + +The class provides a buffer that contains, accesses and manipulates +TUint8 data. The buffer itself is on the heap, and is managed by the class. + +Internally, RBuf8 behaves in one of two ways: + +- as a TPtr8 descriptor type, where the buffer just contains data +- as a pointer to a heap descriptor, an HBufC8* type, where the buffer + contains both descriptor information and the data. + +Note that the handling of the distinction is hidden from view. + +An RBuf8 object can allocate its own buffer. Alternatively, it can take +ownership of a pre-existing section of allocated memory, or it can take +ownership of a pre-existing heap descriptor. It can also reallocate the buffer +to resize it. Regardless of the way in which the buffer has been allocated, +the RBuf8 object is responsible for freeing memory when the object itself is closed. + +The class is intended for instantiation. + +The class is derived from TDes8, which means that data can be both accessed +and modified. The base classes provide the functions through which the data is +accessed. In addition, an RBuf8 object can be passed to any function that is +prototyped to take a TDes8 or a TDesC8 type. + +@see TBuf8 +@see TPtr8 +@see HBufC8 +@see TDesC8 +@see TDes8 +*/ + { +public: + IMPORT_C RBuf8(); + IMPORT_C explicit RBuf8(HBufC8* aHBuf); + inline RBuf8& operator=(const TUint8* aString); + inline RBuf8& operator=(const TDesC8& aDes); + inline RBuf8& operator=(const RBuf8& aDes); + IMPORT_C void Assign(const RBuf8& aRBuf); + IMPORT_C void Assign(TUint8 *aHeapCell,TInt aMaxLength); + IMPORT_C void Assign(TUint8 *aHeapCell,TInt aLength,TInt aMaxLength); + IMPORT_C void Assign(HBufC8* aHBuf); + IMPORT_C void Swap(RBuf8& aRBuf); + IMPORT_C TInt Create(TInt aMaxLength); + IMPORT_C void CreateL(TInt aMaxLength); + IMPORT_C TInt CreateMax(TInt aMaxLength); + IMPORT_C void CreateMaxL(TInt aMaxLength); + inline void CreateL(RReadStream &aStream,TInt aMaxLength); + IMPORT_C TInt Create(const TDesC8& aDes); + IMPORT_C void CreateL(const TDesC8& aDes); + IMPORT_C TInt Create(const TDesC8& aDes,TInt aMaxLength); + IMPORT_C void CreateL(const TDesC8& aDes,TInt aMaxLength); + IMPORT_C TInt ReAlloc(TInt aMaxLength); + IMPORT_C void ReAllocL(TInt aMaxLength); + IMPORT_C void Close(); + IMPORT_C void CleanupClosePushL(); + +protected: + IMPORT_C RBuf8(TInt aType,TInt aLength,TInt aMaxLength); + RBuf8(const RBuf8&); // Outlaw copy construction + union + { + TUint8* iEPtrType; //Pointer to data used when RBuf is of EPtr type + HBufC8* iEBufCPtrType; //Pointer to data used when RBuf is of EBufCPtr type + }; + __DECLARE_TEST; + }; + +#endif + +/** +@publishedAll +@released + +Value reference used in operator TLitC8::__TRefDesC8() + +@see TRefByValue +*/ +typedef TRefByValue __TRefDesC8; + + + + +template +class TLitC8 +/** +@publishedAll +@released + +Encapsulates literal text. + +This is always constructed using an _LIT8 macro. + +This class is build independent; i.e. an explicit 8-bit build variant +is generated for both a non-Unicode build and a Unicode build. + +The class has no explicit constructors. + +@see _LIT8 +*/ + { +public: + inline const TDesC8* operator&() const; + inline operator const TDesC8&() const; + inline const TDesC8& operator()() const; + inline operator const __TRefDesC8() const; +public: + /** + @internalComponent + */ + TUint iTypeLength; + + /** + @internalComponent + */ + TText8 iBuf[__Align8(S)]; + }; + +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + +#endif