1 // Copyright (c) 1994-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 "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\include\e32cmn.inl

    15 // 

    16 //

    17 

    18 #ifndef __PLACEMENT_NEW_INLINE

    19 #define __PLACEMENT_NEW_INLINE

    20 // Global placement operator new

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

    22 	{return aBase;}

    23 

    24 // Global placement operator delete

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

    26 	{}

    27 #endif //__PLACEMENT_NEW_INLINE

    28 

    29 #ifndef __PLACEMENT_VEC_NEW_INLINE

    30 #define __PLACEMENT_VEC_NEW_INLINE

    31 // Global placement operator new[]

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

    33 	{return aBase;}

    34 

    35 // Global placement operator delete[]

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

    37 	{}

    38 #endif //__PLACEMENT_VEC_NEW_INLINE

    39 

    40 

    41 // class RAllocator

    42 inline RAllocator::RAllocator()

    43 	{

    44 	iAccessCount=1;

    45 	iHandleCount=0;

    46 	iHandles=0;

    47 	iFlags=0;

    48 	iCellCount=0;

    49 	iTotalAllocSize=0;

    50 	}

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

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

    53 

    54 // Class RHeap

    55 inline RHeap::RHeap()

    56 	{}

    57 

    58 /**

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

    60 

    61 @publishedAll

    62 @released

    63 */

    64 inline TInt RHeap::MaxLength() const

    65 	{return iMaxLength;}

    66 

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

    68 /**

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

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

    71 */

    72 	{}

    73 

    74 

    75 inline TUint8* RHeap::Base() const

    76 /**

    77 Gets a pointer to the start of the heap.

    78 	

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

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

    81 	

    82 @return A pointer to the base of the heap.

    83 */

    84 	{return iBase;}

    85 

    86 

    87 

    88 

    89 inline TInt RHeap::Size() const

    90 /**

    91 Gets the current size of the heap.

    92 

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

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

    95 minus the cell alignment overhead as shown:

    96 

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

    98 

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

   100 

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

   102 	

   103 @return The size of the heap.

   104 

   105 @see Rheap::Available( )

   106 */

   107 	{return iTop-iBase;}

   108 

   109 

   110 

   111 

   112 inline TInt RHeap::Align(TInt a) const

   113 /**

   114 @internalComponent

   115 */

   116 	{return _ALIGN_UP(a, iAlign);}

   117 

   118 

   119 

   120 

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

   122 /**

   123 @internalComponent

   124 */

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

   126 

   127 

   128 

   129 

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

   131 /**

   132 @internalComponent

   133 */

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

   135 

   136 

   137 

   138 

   139 #ifndef __KERNEL_MODE__

   140 inline void RHeap::Lock() const

   141 /**

   142 @internalComponent

   143 */

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

   145 

   146 

   147 

   148 

   149 inline void RHeap::Unlock() const

   150 /**

   151 @internalComponent

   152 */

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

   154 

   155 

   156 inline TInt RHeap::ChunkHandle() const

   157 /**

   158 @internalComponent

   159 */

   160 	{

   161 	return iChunkHandle;

   162 	}

   163 #endif

   164 

   165 

   166 

   167 

   168 // Class TRefByValue

   169 template <class T>

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

   171 	: iRef(aRef)

   172 /**

   173 Constructs this value reference for the specified referenced object.

   174 

   175 @param aRef The referenced object.

   176 */

   177 	{}

   178 

   179 

   180 

   181 

   182 template <class T>

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

   184 /**

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

   186 */

   187 	{return(iRef);}

   188 

   189 

   190 

   191 

   192 /**

   193 Creates the logical channel.

   194 

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

   196                   is to be constructed. This is the name by which

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

   198 				  the DLogicalDevice derived class, is known.

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

   200                   normally checks this against the version of the logical

   201 				  channel, returning KErrNotSupported if the logical channel

   202 				  is not compatible.

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

   204                   the flag KDeviceAllowUnit is set in the iParseMask data

   205 				  member of the LDD factory object.

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

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

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

   209 				  derived class, is known.

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

   211 				  the logical device does not require an accompanying physical

   212 				  device.

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

   214                   information for the physical device. This argument only has

   215 				  meaning if the KDeviceAllowInfo flag is set in the iParseMask

   216 				  data member of the LDD factory object.

   217 @param aType      An enumeration whose enumerators define the ownership of

   218                   this handle. If not explicitly specified, EOwnerProcess is

   219 				  taken as default.

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

   221                      local/private to the current process.

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

   223                      other processes using the IPC mechanisms for handle passing.

   224 	

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

   226          error codes.

   227 */

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

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

   230 

   231 

   232 

   233 

   234 // Class TChar

   235 inline TChar::TChar()

   236 /**

   237 Default constructor.

   238 

   239 Constructs this character object with an undefined value.

   240 */

   241 	{}

   242 

   243 

   244 

   245 

   246 inline TChar::TChar(TUint aChar)

   247 	: iChar(aChar)

   248 /**

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

   250 

   251 @param aChar The initialisation value.

   252 */

   253 	{}

   254 

   255 

   256 

   257 

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

   259 /**

   260 Subtracts an unsigned integer value from this character object.

   261 

   262 This character object is changed by the operation.

   263 

   264 @param aChar The value to be subtracted.

   265 

   266 @return A reference to this character object.

   267 */

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

   269 

   270 

   271 

   272 

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

   274 /**

   275 Adds an unsigned integer value to this character object.

   276 

   277 This character object is changed by the operation.

   278 

   279 @param aChar The value to be added.

   280 

   281 @return A reference to this character object.

   282 */

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

   284 

   285 

   286 

   287 

   288 inline TChar TChar::operator-(TUint aChar)

   289 /**

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

   291 object.

   292 

   293 This character object is not changed.

   294 

   295 @param aChar The value to be subtracted.

   296 

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

   298         operation.

   299 */

   300 	{return(iChar-aChar);}

   301 

   302 

   303 

   304 

   305 inline TChar TChar::operator+(TUint aChar)

   306 /** 

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

   308 

   309 This character object is not changed.

   310 

   311 @param aChar The value to be added.

   312 

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

   314 */

   315 	{return(iChar+aChar);}

   316 

   317 

   318 

   319 

   320 inline TChar::operator TUint() const

   321 /**

   322 Gets the value of the character as an unsigned integer. 

   323 

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

   325 this character object.

   326 */

   327 	{return(iChar);}

   328 

   329 

   330 

   331 

   332 // Class TDesC8

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

   334 /**

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

   336 descriptor's data.

   337 

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

   339 

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

   341             with this descriptor's data.

   342             

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

   344 

   345 @see TDesC8::Compare

   346 */

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

   348 

   349 

   350 

   351 

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

   353 /**

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

   355 specified descriptor's data.

   356 

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

   358 

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

   360             with this descriptor's data. 

   361             

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

   363 

   364 @see TDesC8::Compare

   365 */

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

   367 

   368 

   369 

   370 

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

   372 /**

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

   374 descriptor's data.

   375 

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

   377 

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

   379             with this descriptor's data. 

   380             

   381 @return True if greater than, false otherwise. 

   382 

   383 @see TDesC8::Compare

   384 */

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

   386 

   387 

   388 

   389 

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

   391 /**

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

   393 specified descriptor's data.

   394 

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

   396 

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

   398             with this descriptor's data. 

   399             

   400 @return True if greater than, false otherwise.

   401 

   402 @see TDesC8::Compare

   403 */

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

   405 

   406 

   407 

   408 

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

   410 /**

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

   412 descriptor's data.

   413 

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

   415 

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

   417             with this descriptor's data. 

   418             

   419 @return True if equal, false otherwise. 

   420 

   421 @see TDesC8::Compare

   422 */

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

   424 

   425 

   426 

   427 

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

   429 /**

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

   431 descriptor's data.

   432 

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

   434 

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

   436             with this descriptor's data. 

   437             

   438 @return True if not equal, false otherwise. 

   439 

   440 @see TDesC8::Compare

   441 */

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

   443 

   444 

   445 

   446 

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

   448 /**

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

   450 

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

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

   453                leftmost data position. 

   454                

   455 @return A reference to the data item.

   456 

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

   458                 length of the descriptor.

   459 */

   460 	{return(AtC(anIndex));}

   461 

   462 

   463 

   464 

   465 inline TInt TDesC8::Length() const

   466 /**

   467 Gets the length of the data.

   468 

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

   470 

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

   472 */

   473 	{return(iLength&KMaskDesLength8);}

   474 

   475 

   476 

   477 

   478 inline TInt TDesC8::Size() const

   479 /**

   480 Gets the size of the data.

   481 

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

   483 

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

   485 */

   486 	{return(Length());}

   487 

   488 

   489 

   490 

   491 inline void TDesC8::DoSetLength(TInt aLength)

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

   493 

   494 

   495 

   496 

   497 // Class TPtrC8

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

   499 /**

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

   501 location in memory, whether in RAM or ROM.

   502 

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

   504 

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

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

   507 

   508 @panic USER 29, if aLength is negative.

   509 */

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

   511 

   512 

   513 

   514 

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

   516 /**

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

   518 

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

   520 

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

   522 */

   523 	{new(this) TPtrC8(aDes);}

   524 

   525 

   526 

   527 

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

   529 /**

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

   531 non-modifiable pointer descriptor.

   532 

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

   534 

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

   536 */

   537 	{new(this) TPtrC8(aPtr);}

   538 

   539 

   540 

   541 

   542 

   543 // class TBufCBase8

   544 inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength)

   545 	{return TPtr8(*this,aMaxLength);}

   546 

   547 

   548 

   549 

   550 // Template class TBufC8

   551 template <TInt S>

   552 inline TBufC8<S>::TBufC8()

   553 	: TBufCBase8()

   554 /** 

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

   556 

   557 It contains no data.

   558 

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

   560 is created as part of the buffer descriptor object.

   561 

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

   563 assignment operators.

   564 

   565 @see TBufC8::operator=

   566 */

   567 	{}

   568 

   569 

   570 

   571 

   572 template <TInt S>

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

   574 	: TBufCBase8(aString,S)

   575 /**

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

   577 string.

   578 

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

   580 is created as part of this object.

   581 

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

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

   584 string, excluding the zero terminator.

   585 

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

   587 

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

   589                 greater than the value of the integer template parameter.

   590 */

   591 	{}

   592 

   593 

   594 

   595 

   596 template <TInt S>

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

   598 	: TBufCBase8(aDes,S)

   599 /**

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

   601 existing descriptor.

   602 

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

   604 is created as part of this object.

   605 

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

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

   608 source descriptor.

   609 

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

   611 

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

   613                 greater than the value of the integer template parameter.

   614 */

   615 	{}

   616 

   617 

   618 

   619 

   620 template <TInt S>

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

   622 /**

   623 Copies data into this descriptor, replacing any existing data.

   624 

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

   626 

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

   628 

   629 @return A reference to this descriptor.

   630 

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

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

   633 */

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

   635 

   636 

   637 

   638 

   639 template <TInt S>

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

   641 /**

   642 Copies data into this descriptor, replacing any existing data.

   643 

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

   645 

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

   647 

   648 @return A reference to this descriptor.

   649 

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

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

   652 */

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

   654 

   655 

   656 

   657 

   658 template <TInt S>

   659 inline TPtr8 TBufC8<S>::Des()

   660 /**

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

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

   663 

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

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

   666 descriptor provides a way of changing the data.

   667 

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

   669 descriptor's data.

   670 

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

   672 non-modifiable buffer descriptor.

   673 

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

   675 of the integer template parameter.

   676 

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

   678 both it and this constant buffer descriptor are changed.

   679 

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

   681         8-bit non-modifiable buffer descriptor.

   682 */

   683 	{return DoDes(S);}

   684 

   685 

   686 

   687 

   688 #ifndef __KERNEL_MODE__

   689 // Class HBufC8

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

   691 /**

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

   693 

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

   695 

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

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

   698 than the maximum length specified when this descriptor was created or

   699 last re-allocated.

   700 

   701 @param aLcb The source 8-bit heap descriptor.

   702 

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

   704 

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

   706                 maximum length of this (target) descriptor

   707 */

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

   709 

   710 

   711 

   712 

   713 // Class RBuf8

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

   715 /**

   716 Copies data into this descriptor replacing any existing data.

   717 

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

   719 

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

   721 

   722 @return A reference to this, the target descriptor.

   723 

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

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

   726 */

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

   728 

   729 

   730 

   731 

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

   733 /**

   734 Copies data into this descriptor replacing any existing data.

   735 

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

   737 

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

   739 

   740 @return A reference to this, the target descriptor.

   741 

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

   743                 maximum length of this (target) descriptor.

   744 */

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

   746 

   747 

   748 

   749 

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

   751 /**

   752 Copies data into this descriptor replacing any existing data.

   753 

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

   755 

   756 @param aDes A 8-bit buffer descriptor.

   757 

   758 @return A reference to this, the target descriptor.

   759 

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

   761                 maximum length of this (target) descriptor.

   762 */

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

   764 

   765 

   766 

   767 

   768 /**

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

   770 data from the specified read stream; leaves on failure.

   771 			 

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

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

   774 by the data itself.

   775 

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

   777 variant and then assigning the resulting heap descriptor using

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

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

   780 

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

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

   783 the upper limit as specified by the aMaxLength parameter.

   784 

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

   786                   assigned to the new descriptor, are taken.

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

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

   789                   otherwise the	underlying function will panic.

   790 */

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

   792 	{

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

   794 	}

   795 #endif

   796 

   797 

   798 

   799 

   800 // Class TDes8

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

   802 /**

   803 Copies data into this descriptor replacing any existing data.

   804 

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

   806 

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

   808 

   809 @return A reference to this, the target descriptor.

   810 

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

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

   813 */

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

   815 

   816 

   817 

   818 

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

   820 /**

   821 Copies data into this descriptor replacing any existing data.

   822 

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

   824 

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

   826  

   827 @return A reference to this, the target descriptor.

   828 

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

   830                 maximum length of this (target) descriptor.

   831 */

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

   833 

   834 

   835 

   836 

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

   838 /**

   839 Copies data into this descriptor replacing any existing data.

   840 

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

   842 

   843 @param aDes An 8-bit modifiable descriptor.

   844 

   845 @return A reference to this, the target descriptor.

   846 

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

   848                 maximum length of this (target) descriptor.

   849 */

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

   851 

   852 

   853 

   854 

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

   856 /**

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

   858 to this descriptor.

   859 

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

   861 

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

   863 

   864 @return A reference to this descriptor.

   865 

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

   867                 maximum length.  

   868 */

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

   870 

   871 

   872 

   873 

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

   875 /**

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

   877 

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

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

   880 			   data position.

   881 

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

   883 

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

   885                 current length of this descriptor.

   886 */

   887 	{return(AtC(anIndex));}

   888 

   889 

   890 

   891 

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

   893 /**

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

   895 data.

   896 

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

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

   899 			   data position.

   900 

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

   902 

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

   904                 current length of this descriptor.

   905 */

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

   907 

   908 

   909 

   910 

   911 inline TInt TDes8::MaxLength() const

   912 /**

   913 Gets the maximum length of the descriptor.

   914 

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

   916 the descriptor can represent.

   917 

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

   919 */

   920 	{return(iMaxLength);}

   921 

   922 

   923 

   924 

   925 inline TInt TDes8::MaxSize() const

   926 /**

   927 Gets the maximum size of the descriptor.

   928 

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

   930 the descriptor can occupy.

   931 

   932 @return The maximum size of the descriptor data.

   933 */

   934 	{return(iMaxLength);}

   935 

   936 

   937 

   938 

   939 inline TUint8 * TDes8::WPtr() const

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

   941 

   942 

   943 

   944 

   945 // Class TPtr8

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

   947 /**

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

   949 existing data.

   950 

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

   952 

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

   954 

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

   956 

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

   958                 greater than the maximum length of this descriptor.

   959 */

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

   961 

   962 

   963 

   964 

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

   966 /**

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

   968 existing data.

   969 

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

   971 

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

   973             into this descriptor.

   974 

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

   976 

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

   978                 length of this descriptor.

   979 */

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

   981 

   982 

   983 

   984 

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

   986 /**

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

   988 existing data.

   989 

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

   991 

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

   993             into this descriptor.

   994 

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

   996 

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

   998                 length of this descriptor.

   999 */

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

  1001 

  1002 

  1003 

  1004 

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

  1006 /**

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

  1008 in memory, whether in RAM or ROM.

  1009 

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

  1011 values.

  1012 

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

  1014 @param aLength    The length of the descriptor.

  1015 @param aMaxLength The maximum length of the descriptor.

  1016 

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

  1018                 this descriptor.

  1019 @panic USER 30, if aMaxLength is negative.

  1020 */

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

  1022 

  1023 

  1024 

  1025 

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

  1027 /**

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

  1029 pointer descriptor.

  1030   

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

  1032 maximum length as the source pointer descriptor.

  1033 

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

  1035 */

  1036 	{new(this) TPtr8(aPtr);}

  1037 

  1038 

  1039 

  1040 

  1041 // Template class TBuf8

  1042 template <TInt S>

  1043 inline TBuf8<S>::TBuf8()

  1044 	: TBufBase8(S)

  1045 /**

  1046 Constructs an empty 8-bit modifiable buffer descriptor.

  1047 

  1048 It contains no data.

  1049 

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

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

  1052 */

  1053 	{}

  1054 

  1055 

  1056 

  1057 

  1058 template <TInt S>

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

  1060 	: TBufBase8(aLength,S)

  1061 /**

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

  1063 to the specified value.

  1064 

  1065 No data is assigned to the descriptor.

  1066 

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

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

  1069 

  1070 @param aLength The length of this modifiable buffer descriptor.

  1071 

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

  1073                 value of the integer template parameter.

  1074 */

  1075 	{}

  1076 

  1077 

  1078 

  1079 

  1080 template <TInt S>

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

  1082 	: TBufBase8(aString,S)

  1083 /**

  1084 Constructs the 8-bit modifiable buffer descriptor from a

  1085 zero terminated string.

  1086 

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

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

  1089 

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

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

  1092 length of the string, excluding the zero terminator.

  1093 

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

  1095 

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

  1097                 is greater than the value of the integer template parameter.

  1098 */

  1099 	{}

  1100 

  1101 

  1102 

  1103 

  1104 template <TInt S>

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

  1106 	: TBufBase8(aDes,S)

  1107 /**

  1108 Constructs the 8-bit modifiable buffer descriptor from any existing

  1109 8-bit descriptor.

  1110 

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

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

  1113 

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

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

  1116 the length of the source descriptor.

  1117 

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

  1119 

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

  1121                 value of the integer template parameter.

  1122 */

  1123 	{}

  1124 

  1125 

  1126 

  1127 

  1128 template <TInt S>

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

  1130 /**

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

  1132 existing data.

  1133 

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