Symaptic: os/kernelhwsrv/kernel/eka/include/e32des8.h@260cb5ec6c19

     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 //

    18 #ifndef __E32DES8_H__

    19 #define __E32DES8_H__

    21 /**

    22 @internalComponent

    23 */

    24 const TUint KMaskDesLength8=0xfffffff;

    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

    39 Abstract base class for 8-bit non-modifiable descriptors.

    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.

    45 Data represented by this class is treated as a contiguous set of 8-bit (i.e.

    46 single byte) values or data items.

    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.

    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

   114 8-bit non-modifiable pointer descriptor.

   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.

   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.

   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

   152 An interface that defines an overflow handler for an 8-bit descriptor.

   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.

   157 A derived class must provide an implementation for the Overflow() member

   158 function.

   160 @see TDes8::AppendFormat

   161 */

   162 	{

   163 public:

   164     /**

   165     Handles the overflow.

   167     This function is called when the TDes8::AppendFormat() variant that takes

   168     an overflow handler argument, fails.

   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

   181 A derived class which provides an implementation for the Overflow() member function

   182 where truncation is required.

   184 @see TDes16::AppendFormat

   185 */

   186 	{

   187 public:

   188 	/**

   189 	Handles the overflow.

   191 	This function is called when the TDes8::AppendFormat()

   192 	variant that takes an overflow handler argument, fails.

   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

   207 Abstract base class for 8-bit modifiable descriptors.

   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.

   213 The class adds to the behaviour provided by TDesC8.

   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.

   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

   322 8-bit modifiable pointer descriptor.

   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.

   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.

   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

   381 8-bit heap descriptor.

   383 This is a descriptor class which provides a buffer of fixed length, allocated

   384 on the heap, for containing and accessing data.

   386 The class is intended for instantiation.

   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.

   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.

   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.

   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.

   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

   450 8-bit non-modifiable buffer descriptor.

   452 This is a descriptor class which provides a buffer of fixed length for

   453 containing and accessing TUint8 data.

   455 The class intended for instantiation. The 8-bit data that the descriptor

   456 represents is part of the descriptor object itself.

   458 The class is templated, based on an integer value which defines the size of

   459 the descriptor's data area.

   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.

   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

   500 A descriptor class which provides a buffer of fixed length for

   501 containing, accessing and manipulating TUint8 data.

   503 The class is intended for instantiation. The 8-bit data that the descriptor

   504 represents is part of the descriptor object itself.

   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.

   510 The data is intended to be both accessed and modified. The base classes provide

   511 the functions through which the data is accessed.

   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 	};

   531 //

   532 template <TInt S>

   533 class TAlignedBuf8 : public TBufBase8

   534 /**

   535 @internalComponent

   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.

   541 At present this class is not intended for general use. It exists

   542 solely to support TPckgBuf which derives from it.

   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 };

   563 #ifndef __KERNEL_MODE__

   565 class RBuf8 : public TDes8

   566 /**

   567 @publishedAll

   568 @released

   570 8 bit resizable buffer descriptor.

   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.

   575 Internally, RBuf8 behaves in one of two ways:

   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.

   581 Note that the handling of the distinction is hidden from view.

   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.

   589 The class is intended for instantiation.

   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.

   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();

   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 	};

   639 #endif

   641 /**

   642 @publishedAll

   643 @released

   645 Value reference used in operator TLitC8::__TRefDesC8()

   647 @see TRefByValue

   648 */

   649 typedef TRefByValue<const TDesC8> __TRefDesC8;

   654 template <TInt S>

   655 class TLitC8

   656 /**

   657 @publishedAll

   658 @released

   660 Encapsulates literal text.

   662 This is always constructed using an _LIT8 macro.

   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.

   667 The class has no explicit constructors.

   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;

   683 	/**

   684     @internalComponent

   685     */

   686 	TText8 iBuf[__Align8(S)];

   687 	};

   689 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

   690 #include <e32des8_private.h>

   691 #endif

   693 #endif

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