kernel/eka/include/e32des8.h
changeset 0 a41df078684a
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of the License "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // e32\include\e32des8.h
       
    15 // 
       
    16 //
       
    17 
       
    18 #ifndef __E32DES8_H__
       
    19 #define __E32DES8_H__
       
    20 
       
    21 /**
       
    22 @internalComponent
       
    23 */
       
    24 const TUint KMaskDesLength8=0xfffffff;
       
    25 
       
    26 class TBufCBase8;
       
    27 class TDes8;
       
    28 class TPtrC8;
       
    29 class TPtr8;
       
    30 class TPtr16;
       
    31 #ifndef __KERNEL_MODE__
       
    32 class HBufC8;
       
    33 #endif
       
    34 class TDesC8
       
    35 /**
       
    36 @publishedAll
       
    37 @released
       
    38 
       
    39 Abstract base class for 8-bit non-modifiable descriptors.
       
    40 
       
    41 The class encapsulates the data member containing the length of data
       
    42 represented by an 8-bit descriptor. It also provides member functions through
       
    43 which the data can be accessed, but not modified.
       
    44 
       
    45 Data represented by this class is treated as a contiguous set of 8-bit (i.e. 
       
    46 single byte) values or data items.
       
    47 
       
    48 This class cannot be instantiated as it is intended to form part of a class 
       
    49 hierarchy; it provides a well defined part of descriptor behaviour. It can, 
       
    50 however, be passed as an argument type for functions which want access to 
       
    51 descriptor data but do not need to modify that data.
       
    52 
       
    53 @see TDesC
       
    54 @see TPtrC8
       
    55 */
       
    56     {
       
    57 public:
       
    58 	inline TBool operator<(const TDesC8 &aDes) const;
       
    59 	inline TBool operator<=(const TDesC8 &aDes) const;
       
    60 	inline TBool operator>(const TDesC8 &aDes) const;
       
    61 	inline TBool operator>=(const TDesC8 &aDes) const;
       
    62 	inline TBool operator==(const TDesC8 &aDes) const;
       
    63 	inline TBool operator!=(const TDesC8 &aDes) const;
       
    64 	inline const TUint8 &operator[](TInt anIndex) const;
       
    65 	inline TInt Length() const;
       
    66 	inline TInt Size() const;
       
    67 	IMPORT_C const TUint8 *Ptr() const;
       
    68 	IMPORT_C TInt Compare(const TDesC8 &aDes) const;
       
    69 	IMPORT_C TInt Match(const TDesC8 &aDes) const;
       
    70 	IMPORT_C TInt MatchF(const TDesC8 &aDes) const;
       
    71 	IMPORT_C TInt MatchC(const TDesC8 &aDes) const;
       
    72 	IMPORT_C TInt Locate(TChar aChar) const;
       
    73 	IMPORT_C TInt LocateReverse(TChar aChar) const;
       
    74 	IMPORT_C TInt Find(const TDesC8 &aDes) const;
       
    75 	IMPORT_C TInt Find(const TUint8 *pS,TInt aLenS) const;
       
    76 	IMPORT_C TPtrC8 Left(TInt aLength) const;
       
    77 	IMPORT_C TPtrC8 Right(TInt aLength) const;
       
    78 	IMPORT_C TPtrC8 Mid(TInt aPos) const;
       
    79 	IMPORT_C TPtrC8 Mid(TInt aPos,TInt aLength) const;
       
    80 	IMPORT_C TInt CompareF(const TDesC8 &aDes) const;
       
    81 #ifndef __KERNEL_MODE__
       
    82 	IMPORT_C TInt CompareC(const TDesC8 &aDes) const;
       
    83 	IMPORT_C TInt LocateF(TChar aChar) const;
       
    84 	IMPORT_C TInt LocateReverseF(TChar aChar) const;
       
    85 	IMPORT_C TInt FindF(const TDesC8 &aDes) const;
       
    86 	IMPORT_C TInt FindF(const TUint8 *pS,TInt aLenS) const;
       
    87 	IMPORT_C TInt FindC(const TDesC8 &aDes) const;
       
    88 	IMPORT_C TInt FindC(const TUint8 *pS,TInt aLenS) const;
       
    89 	IMPORT_C HBufC8 *Alloc() const;
       
    90 	IMPORT_C HBufC8 *AllocL() const;
       
    91 	IMPORT_C HBufC8 *AllocLC() const;
       
    92 #endif
       
    93 protected:
       
    94 	inline TDesC8(TInt aType,TInt aLength);
       
    95 	inline TDesC8() {}
       
    96 // delay this for a while
       
    97 #ifdef SYMBIAN_FIX_TDESC_CONSTRUCTORS
       
    98 	inline TDesC8( const TDesC8& aOther) : iLength(aOther.iLength) {}
       
    99 #endif
       
   100 //	inline ~TDesC8() {}			Commented out for the moment since it breaks code
       
   101 	inline TInt Type() const;
       
   102 	inline void DoSetLength(TInt aLength);
       
   103 	IMPORT_C const TUint8 &AtC(TInt anIndex) const;
       
   104 private:
       
   105 	TUint iLength;
       
   106 	__DECLARE_TEST;
       
   107     };
       
   108 //
       
   109 class TPtrC8 : public TDesC8
       
   110 /**
       
   111 @publishedAll
       
   112 @released
       
   113 
       
   114 8-bit non-modifiable pointer descriptor.
       
   115 
       
   116 This is a descriptor class intended for instantiation and encapsulates a
       
   117 pointer to the 8-bit data that it represents. The data can live in ROM or RAM
       
   118 and this location is separate from the descriptor object itself.
       
   119 
       
   120 The data is intended to be accessed, but not changed, through this descriptor. 
       
   121 The base class provides the functions through which data is accessed.
       
   122 
       
   123 @see TPtr8
       
   124 @see TDesC8
       
   125 @see TDes8
       
   126 @see TBufC8
       
   127 @see TBuf8
       
   128 @see HBufC8
       
   129 */
       
   130 	{
       
   131 public:
       
   132 	IMPORT_C TPtrC8();
       
   133 	IMPORT_C TPtrC8(const TDesC8 &aDes);
       
   134 	IMPORT_C TPtrC8(const TUint8 *aString);
       
   135 	IMPORT_C TPtrC8(const TUint8 *aBuf,TInt aLength);
       
   136 	inline void Set(const TUint8 *aBuf,TInt aLength);
       
   137 	inline void Set(const TDesC8 &aDes);
       
   138 	inline void Set(const TPtrC8& aPtr);
       
   139 private:
       
   140 	TPtrC8& operator=(const TPtrC8 &aDes);
       
   141 protected:
       
   142 	const TUint8 *iPtr;
       
   143 private:
       
   144 	__DECLARE_TEST;
       
   145 	};
       
   146 //
       
   147 class TDes8Overflow
       
   148 /**
       
   149 @publishedAll
       
   150 @released
       
   151 
       
   152 An interface that defines an overflow handler for an 8-bit descriptor.
       
   153 
       
   154 The interface encapsulates a function that is called when an attempt to append 
       
   155 formatted text fails because the descriptor is already at its maximum length.
       
   156 
       
   157 A derived class must provide an implementation for the Overflow() member
       
   158 function.
       
   159 
       
   160 @see TDes8::AppendFormat
       
   161 */
       
   162 	{
       
   163 public:
       
   164     /**
       
   165     Handles the overflow.
       
   166     
       
   167     This function is called when the TDes8::AppendFormat() variant that takes
       
   168     an overflow handler argument, fails.
       
   169 	
       
   170 	@param aDes The 8-bit modifiable descriptor whose overflow results in the 
       
   171 	            call to this overflow handler.
       
   172 	*/
       
   173 	virtual void Overflow(TDes8 &aDes)=0;
       
   174 	};
       
   175 //
       
   176 class TDes8IgnoreOverflow : public TDes8Overflow
       
   177 /**
       
   178 @publishedAll
       
   179 @released
       
   180 
       
   181 A derived class which provides an implementation for the Overflow() member function
       
   182 where truncation is required.
       
   183 
       
   184 @see TDes16::AppendFormat
       
   185 */
       
   186 	{
       
   187 public:
       
   188 	/**
       
   189 	Handles the overflow.
       
   190 	
       
   191 	This function is called when the TDes8::AppendFormat() 
       
   192 	variant that takes an overflow handler argument, fails.
       
   193 	
       
   194 	@param aDes The 8-bit modifiable descriptor whose overflow results in the 
       
   195 	            call to this overflow handler.
       
   196 	*/
       
   197 	IMPORT_C virtual void Overflow(TDes8 &aDes);
       
   198 	};
       
   199 //
       
   200 class TDesC16;
       
   201 class TRealFormat;
       
   202 class TDes8 : public TDesC8
       
   203 /** 
       
   204 @publishedAll
       
   205 @released
       
   206 
       
   207 Abstract base class for 8-bit modifiable descriptors.
       
   208 
       
   209 The class encapsulates the data member containing the maximum length of data
       
   210 represented by an 8-bit descriptor. It also provides member functions through
       
   211 which the data can be modified.
       
   212 
       
   213 The class adds to the behaviour provided by TDesC8.
       
   214 
       
   215 This class cannot be instantiated as it is intended to form part of a class 
       
   216 hierarchy; it provides a well defined part of descriptor behaviour. It can, 
       
   217 however, be passed as an argument type for functions which need to both modify 
       
   218 and access descriptor data.
       
   219 
       
   220 @see TDes
       
   221 @see TDesC8
       
   222 @see TDesC16
       
   223 */
       
   224 	{
       
   225 public:
       
   226 	inline TDes8& operator=(const TUint8 *aString);
       
   227 	inline TDes8& operator=(const TDesC8 &aDes);
       
   228 	inline TDes8& operator=(const TDes8 &aDes);
       
   229 	inline TInt MaxLength() const;
       
   230 	inline TInt MaxSize() const;
       
   231 	inline const TUint8 &operator[](TInt anIndex) const;
       
   232 	inline TUint8 &operator[](TInt anIndex);
       
   233 	inline TDes8 &operator+=(const TDesC8 &aDes);
       
   234 	IMPORT_C void Zero();
       
   235  	IMPORT_C void SetLength(TInt aLength);
       
   236  	IMPORT_C void SetMax();
       
   237 	IMPORT_C void Copy(const TDesC8 &aDes);
       
   238 	IMPORT_C void Copy(const TUint8 *aBuf,TInt aLength);
       
   239 	IMPORT_C void Copy(const TUint8 *aString);
       
   240 	IMPORT_C void Copy(const TDesC16 &aDes);
       
   241 	IMPORT_C void Append(TChar aChar);
       
   242 	IMPORT_C void Append(const TDesC8 &aDes);
       
   243 	IMPORT_C void Append(const TDesC16 &aDes);
       
   244 	IMPORT_C void Append(const TUint8 *aBuf,TInt aLength);
       
   245 	IMPORT_C void Fill(TChar aChar);
       
   246 	IMPORT_C void Fill(TChar aChar,TInt aLength);
       
   247 	IMPORT_C void FillZ();
       
   248 	IMPORT_C void FillZ(TInt aLength);
       
   249 	IMPORT_C void Num(TInt64 aVal);
       
   250 	IMPORT_C void Num(TUint64 aVal, TRadix aRadix);
       
   251 	IMPORT_C void NumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth);
       
   252 	IMPORT_C void AppendNum(TInt64 aVal);
       
   253 	IMPORT_C void AppendNum(TUint64 aVal, TRadix aRadix);
       
   254 	IMPORT_C void AppendNumFixedWidth(TUint aVal,TRadix aRadix,TInt aWidth);
       
   255 #ifndef __KERNEL_MODE__
       
   256 	IMPORT_C TPtr8 LeftTPtr(TInt aLength) const;
       
   257 	IMPORT_C TPtr8 RightTPtr(TInt aLength) const;
       
   258 	IMPORT_C TPtr8 MidTPtr(TInt aPos) const;
       
   259 	IMPORT_C TPtr8 MidTPtr(TInt aPos,TInt aLength) const;
       
   260 	IMPORT_C const TUint8 *PtrZ();
       
   261 	IMPORT_C void CopyF(const TDesC8 &aDes);
       
   262 	IMPORT_C void CopyC(const TDesC8 &aDes);
       
   263 	IMPORT_C void CopyLC(const TDesC8 &aDes);
       
   264 	IMPORT_C void CopyUC(const TDesC8 &aDes);
       
   265 	IMPORT_C void CopyCP(const TDesC8 &aDes);
       
   266 	IMPORT_C void Swap(TDes8 &aDes);
       
   267 	IMPORT_C void AppendFill(TChar aChar,TInt aLength);
       
   268 	IMPORT_C void ZeroTerminate();
       
   269 	IMPORT_C void Fold();
       
   270 	IMPORT_C void Collate();
       
   271 	IMPORT_C void LowerCase();
       
   272 	IMPORT_C void UpperCase();
       
   273 	IMPORT_C void Capitalize();
       
   274 	IMPORT_C void Repeat(const TUint8 *aBuf,TInt aLength);
       
   275 	IMPORT_C void Repeat(const TDesC8 &aDes);
       
   276 	IMPORT_C void Trim();
       
   277 	IMPORT_C void TrimAll();
       
   278 	IMPORT_C void TrimLeft();
       
   279 	IMPORT_C void TrimRight();
       
   280 	IMPORT_C void Insert(TInt aPos,const TDesC8 &aDes);
       
   281 	IMPORT_C void Delete(TInt aPos,TInt aLength);
       
   282 	IMPORT_C void Replace(TInt aPos,TInt aLength,const TDesC8 &aDes);
       
   283 	IMPORT_C void Justify(const TDesC8 &aDes,TInt aWidth,TAlign anAlignment,TChar aFill);
       
   284 	IMPORT_C void NumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth);
       
   285 	IMPORT_C void NumUC(TUint64 aVal, TRadix aRadix=EDecimal);
       
   286 	IMPORT_C TInt Num(TReal aVal,const TRealFormat &aFormat) __SOFTFP;
       
   287 	IMPORT_C void AppendNumFixedWidthUC(TUint aVal,TRadix aRadix,TInt aWidth);
       
   288 	IMPORT_C TInt AppendNum(TReal aVal,const TRealFormat &aFormat) __SOFTFP;
       
   289 	IMPORT_C void AppendNumUC(TUint64 aVal,TRadix aRadix=EDecimal);
       
   290 	IMPORT_C void Format(TRefByValue<const TDesC8> aFmt,...);
       
   291 	IMPORT_C void FormatList(const TDesC8 &aFmt,VA_LIST aList);
       
   292 	IMPORT_C void AppendJustify(const TDesC8 &Des,TInt aWidth,TAlign anAlignment,TChar aFill);
       
   293 	IMPORT_C void AppendJustify(const TDesC8 &Des,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill);
       
   294 	IMPORT_C void AppendJustify(const TUint8 *aString,TInt aWidth,TAlign anAlignment,TChar aFill);
       
   295 	IMPORT_C void AppendJustify(const TUint8 *aString,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill);
       
   296 	IMPORT_C void AppendFormat(TRefByValue<const TDesC8> aFmt,TDes8Overflow *aOverflowHandler,...);
       
   297 	IMPORT_C void AppendFormat(TRefByValue<const TDesC8> aFmt,...);
       
   298 	IMPORT_C void AppendFormatList(const TDesC8 &aFmt,VA_LIST aList,TDes8Overflow *aOverflowHandler=NULL);
       
   299 	IMPORT_C TPtr16 Expand();
       
   300 	IMPORT_C void Collapse();
       
   301 #endif //__KERNEL_MODE__
       
   302 protected:
       
   303 	inline TDes8(TInt aType,TInt aLength,TInt aMaxLength);
       
   304 	inline TUint8 *WPtr() const;
       
   305 	inline TDes8() {}
       
   306 // delay this for a while
       
   307 #ifdef SYMBIAN_FIX_TDESC_CONSTRUCTORS
       
   308 	inline TDes8(const TDes8& aOther) : TDesC8(aOther), iMaxLength(aOther.iMaxLength) {}
       
   309 #endif
       
   310 	void DoAppendNum(TUint64 aVal, TRadix aRadix, TUint aA, TInt aW);
       
   311 	void DoPadAppendNum(TInt aLength, TInt aW, const TUint8* aBuf);
       
   312 protected:
       
   313 	TInt iMaxLength;
       
   314 	__DECLARE_TEST;
       
   315     };
       
   316 //
       
   317 class TPtr8 : public TDes8
       
   318 /**
       
   319 @publishedAll
       
   320 @released
       
   321 
       
   322 8-bit modifiable pointer descriptor.
       
   323 
       
   324 This is a descriptor class intended for instantiation and encapsulates a
       
   325 pointer to the 8-bit data that it represents. The data can live in ROM or
       
   326 RAM and this location is separate from the descriptor object itself.
       
   327 
       
   328 The data is intended to be accessed and modified through this descriptor. 
       
   329 The base classes provide the functions through which the data can be 
       
   330 manipulated.
       
   331 
       
   332 @see TPtr
       
   333 @see TPtrC8
       
   334 @see TDesC8
       
   335 @see TDes8
       
   336 @see TBufC8
       
   337 @see TBuf8
       
   338 @see HBufC8
       
   339 */
       
   340 	{
       
   341 public:
       
   342 	IMPORT_C TPtr8(TUint8 *aBuf,TInt aMaxLength);
       
   343 	IMPORT_C TPtr8(TUint8 *aBuf,TInt aLength,TInt aMaxLength);
       
   344 	inline TPtr8& operator=(const TUint8 *aString);
       
   345 	inline TPtr8& operator=(const TDesC8& aDes);
       
   346 	inline TPtr8& operator=(const TPtr8& aPtr);
       
   347 	inline void Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength);
       
   348 	inline void Set(const TPtr8 &aPtr);
       
   349 private:
       
   350 	IMPORT_C TPtr8(TBufCBase8 &aLcb,TInt aMaxLength);
       
   351 protected:
       
   352 	TUint8 *iPtr;
       
   353 private:
       
   354 	friend class TBufCBase8;
       
   355 	__DECLARE_TEST;
       
   356 	};
       
   357 //
       
   358 class TBufCBase8 : public TDesC8
       
   359 /**
       
   360 @internalAll
       
   361 */
       
   362 	{
       
   363 protected:
       
   364 	IMPORT_C TBufCBase8();
       
   365 	inline TBufCBase8(TInt aLength);
       
   366 	IMPORT_C TBufCBase8(const TUint8 *aString,TInt aMaxLength);
       
   367 	IMPORT_C TBufCBase8(const TDesC8 &aDes,TInt aMaxLength);
       
   368 	IMPORT_C void Copy(const TUint8 *aString,TInt aMaxLength);
       
   369 	IMPORT_C void Copy(const TDesC8 &aDes,TInt aMaxLength);
       
   370 	inline TPtr8 DoDes(TInt aMaxLength);
       
   371 	inline TUint8 *WPtr() const;
       
   372 	};
       
   373 //
       
   374 #ifndef __KERNEL_MODE__
       
   375 class RReadStream;
       
   376 class HBufC8 : public TBufCBase8
       
   377 /**
       
   378 @publishedAll
       
   379 @released
       
   380 
       
   381 8-bit heap descriptor.
       
   382 
       
   383 This is a descriptor class which provides a buffer of fixed length, allocated 
       
   384 on the heap, for containing and accessing data.
       
   385 
       
   386 The class is intended for instantiation.
       
   387 
       
   388 Heap descriptors have the important property that they can be made larger 
       
   389 or smaller, changing the size of the descriptor buffer. This is achieved by 
       
   390 reallocating the descriptor. Unlike the behaviour of dynamic buffers, 
       
   391 reallocation is not done automatically.
       
   392 
       
   393 Data is intended to be accessed, but not modified; however, it can be 
       
   394 completely replaced using the assignment operators of this class. The base
       
   395 class (TDesC8) provides the functions through which the data is accessed.
       
   396 
       
   397 The descriptor is hosted by a heap cell, and the 8-bit data that the
       
   398 descriptor represents is part of the descriptor object itself. The size of the
       
   399 cell depends on the requested maximum length of the descriptor buffer when the
       
   400 descriptor is created or re-allocated.
       
   401 
       
   402 It is important to note that the size of the allocated cell, and, therefore, 
       
   403 the resulting maximum length of the descriptor, may be larger than requested 
       
   404 due to the way memory is allocated in Symbian OS. The amount by which this 
       
   405 may be rounded up depends on the platform and build type.
       
   406 
       
   407 @see HBufC
       
   408 @see TPtr8
       
   409 @see TDesC8
       
   410 */
       
   411 	{
       
   412 public:
       
   413 	IMPORT_C static HBufC8 *New(TInt aMaxLength);
       
   414 	IMPORT_C static HBufC8 *NewL(TInt aMaxLength);
       
   415 	IMPORT_C static HBufC8 *NewLC(TInt aMaxLength);
       
   416 	IMPORT_C static HBufC8 *NewMax(TInt aMaxLength);
       
   417 	IMPORT_C static HBufC8 *NewMaxL(TInt aMaxLength);
       
   418 	IMPORT_C static HBufC8 *NewMaxLC(TInt aMaxLength);
       
   419 	IMPORT_C static HBufC8 *NewL(RReadStream &aStream,TInt aMaxLength);
       
   420 	IMPORT_C static HBufC8 *NewLC(RReadStream &aStream,TInt aMaxLength);
       
   421 	IMPORT_C HBufC8& operator=(const TUint8 *aString);
       
   422 	IMPORT_C HBufC8& operator=(const TDesC8 &aDes);
       
   423 	inline HBufC8& operator=(const HBufC8 &aLcb);
       
   424 	IMPORT_C HBufC8 *ReAlloc(TInt aMaxLength);
       
   425 	IMPORT_C HBufC8 *ReAllocL(TInt aMaxLength);
       
   426 	IMPORT_C TPtr8 Des();
       
   427 private:
       
   428 	inline HBufC8(TInt aLength);
       
   429 private:
       
   430 	TText8 iBuf[1];
       
   431 	__DECLARE_TEST;
       
   432 	};
       
   433 #endif
       
   434 //
       
   435 /**
       
   436 @internalComponent
       
   437 */
       
   438 #define __Size8 (sizeof(TInt)/sizeof(TInt8))
       
   439 /**
       
   440 @internalComponent
       
   441 */
       
   442 #define __Align8(s) ((((s)+__Size8-1)/__Size8)*__Size8)
       
   443 //
       
   444 template <TInt S>
       
   445 class TBufC8 : public TBufCBase8
       
   446 /**
       
   447 @publishedAll
       
   448 @released
       
   449 
       
   450 8-bit non-modifiable buffer descriptor. 
       
   451 
       
   452 This is a descriptor class which provides a buffer of fixed length for
       
   453 containing and accessing TUint8 data.
       
   454 
       
   455 The class intended for instantiation. The 8-bit data that the descriptor
       
   456 represents is part of the descriptor object itself. 
       
   457 
       
   458 The class is templated, based on an integer value which defines the size of 
       
   459 the descriptor's data area.
       
   460 
       
   461 The data is intended to be accessed, but not modified; however, it can be 
       
   462 completely replaced using the assignment operators of this class. The base 
       
   463 class provides the functions through which the data is accessed.
       
   464 
       
   465 @see TBufC
       
   466 @see TDesC8
       
   467 @see TPtr8
       
   468 @see TUint8
       
   469 */
       
   470 	{
       
   471 public:
       
   472 	inline TBufC8();
       
   473     inline TBufC8(const TUint8 *aString);
       
   474 	inline TBufC8(const TDesC8 &aDes);
       
   475 	inline TBufC8<S> &operator=(const TUint8 *aString);
       
   476 	inline TBufC8<S> &operator=(const TDesC8 &aDes);
       
   477 	inline TPtr8 Des();
       
   478 protected:
       
   479 	TUint8 iBuf[__Align8(S)];
       
   480 	};
       
   481 //
       
   482 class TBufBase8 : public TDes8
       
   483 /**
       
   484 @internalAll
       
   485 */
       
   486 	{
       
   487 protected:
       
   488 	IMPORT_C TBufBase8(TInt aMaxLength);
       
   489 	IMPORT_C TBufBase8(TInt aLength,TInt aMaxLength);
       
   490 	IMPORT_C TBufBase8(const TUint8* aString,TInt aMaxLength);
       
   491 	IMPORT_C TBufBase8(const TDesC8& aDes,TInt aMaxLength);
       
   492 	};
       
   493 //
       
   494 template <TInt S>
       
   495 class TBuf8 : public TBufBase8
       
   496 /**
       
   497 @publishedAll
       
   498 @released
       
   499 
       
   500 A descriptor class which provides a buffer of fixed length for
       
   501 containing, accessing and manipulating TUint8 data.
       
   502 
       
   503 The class is intended for instantiation. The 8-bit data that the descriptor 
       
   504 represents is part of the descriptor object itself.
       
   505 
       
   506 The class is templated, based on an integer value which determines the size 
       
   507 of the data area which is created as part of the buffer descriptor object; 
       
   508 this is also the maximum length of the descriptor.
       
   509 
       
   510 The data is intended to be both accessed and modified. The base classes provide 
       
   511 the functions through which the data is accessed.
       
   512 
       
   513 @see TBuf
       
   514 @see TDesC8
       
   515 @see TDes8
       
   516 @see TPtr8
       
   517 */
       
   518 	{
       
   519 public:
       
   520 	inline TBuf8();
       
   521 	inline explicit TBuf8(TInt aLength);
       
   522     inline TBuf8(const TUint8* aString);
       
   523 	inline TBuf8(const TDesC8& aDes);
       
   524 	inline TBuf8<S>& operator=(const TUint8* aString);
       
   525 	inline TBuf8<S>& operator=(const TDesC8& aDes);
       
   526 	inline TBuf8<S>& operator=(const TBuf8<S>& aBuf);
       
   527 protected:
       
   528 	TUint8 iBuf[__Align8(S)];
       
   529 	};
       
   530 
       
   531 //
       
   532 template <TInt S>
       
   533 class TAlignedBuf8 : public TBufBase8
       
   534 /**
       
   535 @internalComponent
       
   536 
       
   537 A descriptor class functionally identical to TBuf8, the only
       
   538 difference from it being that TAlignedBuf8's internal buffer 
       
   539 is guaranteed to be 64-bit aligned.
       
   540 
       
   541 At present this class is not intended for general use. It exists
       
   542 solely to support TPckgBuf which derives from it.
       
   543 
       
   544 @see TBuf8
       
   545 @see TPckgBuf
       
   546 */
       
   547 {
       
   548 public:
       
   549 	inline TAlignedBuf8();
       
   550 	inline explicit TAlignedBuf8(TInt aLength);
       
   551     inline TAlignedBuf8(const TUint8* aString);
       
   552 	inline TAlignedBuf8(const TDesC8& aDes);
       
   553 	inline TAlignedBuf8<S>& operator=(const TUint8* aString);
       
   554 	inline TAlignedBuf8<S>& operator=(const TDesC8& aDes);
       
   555 	inline TAlignedBuf8<S>& operator=(const TAlignedBuf8<S>& aBuf);
       
   556 protected:
       
   557 	union {
       
   558 		double only_here_to_force_8byte_alignment;
       
   559 		TUint8 iBuf[__Align8(S)];
       
   560 	};
       
   561 };
       
   562 
       
   563 #ifndef __KERNEL_MODE__
       
   564 
       
   565 class RBuf8 : public TDes8
       
   566 /**
       
   567 @publishedAll
       
   568 @released
       
   569 
       
   570 8 bit resizable buffer descriptor.
       
   571 
       
   572 The class provides a buffer that contains, accesses and manipulates
       
   573 TUint8 data. The buffer itself is on the heap, and is managed by the class.
       
   574 
       
   575 Internally, RBuf8 behaves in one of two ways:
       
   576 
       
   577 - as a TPtr8 descriptor type, where the buffer just contains data
       
   578 - as a pointer to a heap descriptor, an HBufC8* type, where the buffer
       
   579   contains both	descriptor information and the data.
       
   580 
       
   581 Note that the handling of the distinction is hidden from view.
       
   582 
       
   583 An RBuf8 object can allocate its own buffer. Alternatively, it can take
       
   584 ownership of a pre-existing section of allocated memory, or it can take
       
   585 ownership of a pre-existing heap descriptor. It can also reallocate the buffer
       
   586 to resize it. Regardless of the way in which the buffer has been allocated,
       
   587 the RBuf8 object is responsible for freeing memory when the object itself is closed.
       
   588 
       
   589 The class is intended for instantiation.
       
   590 
       
   591 The class is derived from TDes8, which means that data can be both accessed
       
   592 and modified. The base classes provide the functions through which the data is
       
   593 accessed. In addition, an RBuf8 object can be passed to any function that is
       
   594 prototyped to take a TDes8 or a TDesC8 type.
       
   595 
       
   596 @see TBuf8
       
   597 @see TPtr8
       
   598 @see HBufC8
       
   599 @see TDesC8
       
   600 @see TDes8
       
   601 */
       
   602 	{
       
   603 public:
       
   604 	IMPORT_C RBuf8();
       
   605 	IMPORT_C explicit RBuf8(HBufC8* aHBuf);
       
   606 	inline RBuf8& operator=(const TUint8* aString);
       
   607 	inline RBuf8& operator=(const TDesC8& aDes);
       
   608 	inline RBuf8& operator=(const RBuf8& aDes);
       
   609 	IMPORT_C void Assign(const RBuf8& aRBuf);
       
   610 	IMPORT_C void Assign(TUint8 *aHeapCell,TInt aMaxLength);
       
   611 	IMPORT_C void Assign(TUint8 *aHeapCell,TInt aLength,TInt aMaxLength);
       
   612 	IMPORT_C void Assign(HBufC8* aHBuf);
       
   613 	IMPORT_C void Swap(RBuf8& aRBuf);
       
   614 	IMPORT_C TInt Create(TInt aMaxLength);
       
   615 	IMPORT_C void CreateL(TInt aMaxLength);
       
   616 	IMPORT_C TInt CreateMax(TInt aMaxLength);
       
   617 	IMPORT_C void CreateMaxL(TInt aMaxLength);
       
   618 	inline void CreateL(RReadStream &aStream,TInt aMaxLength);
       
   619 	IMPORT_C TInt Create(const TDesC8& aDes);
       
   620 	IMPORT_C void CreateL(const TDesC8& aDes);
       
   621 	IMPORT_C TInt Create(const TDesC8& aDes,TInt aMaxLength);
       
   622 	IMPORT_C void CreateL(const TDesC8& aDes,TInt aMaxLength);
       
   623 	IMPORT_C TInt ReAlloc(TInt aMaxLength);
       
   624 	IMPORT_C void ReAllocL(TInt aMaxLength);
       
   625 	IMPORT_C void Close();
       
   626 	IMPORT_C void CleanupClosePushL();
       
   627 
       
   628 protected:
       
   629 	IMPORT_C RBuf8(TInt aType,TInt aLength,TInt aMaxLength);
       
   630 	RBuf8(const RBuf8&); // Outlaw copy construction
       
   631 	union
       
   632 		{
       
   633 		TUint8* iEPtrType;		//Pointer to data used when RBuf is of EPtr type
       
   634 		HBufC8* iEBufCPtrType;	//Pointer to data used when RBuf is of EBufCPtr type
       
   635 		};
       
   636 	__DECLARE_TEST;
       
   637 	};
       
   638 
       
   639 #endif
       
   640 
       
   641 /**
       
   642 @publishedAll
       
   643 @released
       
   644 
       
   645 Value reference used in operator TLitC8::__TRefDesC8()
       
   646 
       
   647 @see TRefByValue
       
   648 */
       
   649 typedef TRefByValue<const TDesC8> __TRefDesC8;
       
   650 
       
   651 
       
   652 
       
   653 
       
   654 template <TInt S>
       
   655 class TLitC8
       
   656 /**
       
   657 @publishedAll
       
   658 @released
       
   659 
       
   660 Encapsulates literal text. 
       
   661 
       
   662 This is always constructed using an _LIT8 macro.
       
   663 
       
   664 This class is build independent; i.e. an explicit 8-bit build variant
       
   665 is generated for both a non-Unicode build and a Unicode build.
       
   666 
       
   667 The class has no explicit constructors.
       
   668 
       
   669 @see _LIT8
       
   670 */
       
   671 	{
       
   672 public:
       
   673 	inline const TDesC8* operator&() const;
       
   674 	inline operator const TDesC8&() const;
       
   675 	inline const TDesC8& operator()() const;
       
   676 	inline operator const __TRefDesC8() const;
       
   677 public:
       
   678     /**
       
   679     @internalComponent
       
   680     */
       
   681 	TUint iTypeLength;
       
   682 	
       
   683 	/**
       
   684     @internalComponent
       
   685     */
       
   686 	TText8 iBuf[__Align8(S)];
       
   687 	};
       
   688 
       
   689 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
       
   690 #include <e32des8_private.h>
       
   691 #endif
       
   692 
       
   693 #endif