diff -r c55016431358 -r 0a7b44b10206 symport/e32/include/e32cmn.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symport/e32/include/e32cmn.inl Thu Jun 25 15:59:54 2009 +0100 @@ -0,0 +1,7268 @@ +// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Symbian Foundation License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// e32\include\e32cmn.inl +// +// + +#ifndef __PLACEMENT_NEW_INLINE +#define __PLACEMENT_NEW_INLINE +// Global placement operator new +inline TAny* operator new(TUint /*aSize*/, TAny* aBase) __NO_THROW + {return aBase;} + +// Global placement operator delete +inline void operator delete(TAny* /*aPtr*/, TAny* /*aBase*/) __NO_THROW + {} +#endif //__PLACEMENT_NEW_INLINE + +#ifndef __PLACEMENT_VEC_NEW_INLINE +#define __PLACEMENT_VEC_NEW_INLINE +// Global placement operator new[] +inline TAny* operator new[](TUint /*aSize*/, TAny* aBase) __NO_THROW + {return aBase;} + +// Global placement operator delete[] +inline void operator delete[](TAny* /*aPtr*/, TAny* /*aBase*/) __NO_THROW + {} +#endif //__PLACEMENT_VEC_NEW_INLINE + + +// class RAllocator +inline RAllocator::RAllocator() + { + iAccessCount=1; + iHandleCount=0; + iHandles=0; + iFlags=0; + iCellCount=0; + iTotalAllocSize=0; + } +inline void RAllocator::__DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum) + {__DbgMarkCheck(aCountAll, aCount, TPtrC8(aFileName), aLineNum);} + +// Class RHeap +inline RHeap::RHeap() + {} + +/** +@return The maximum length to which the heap can grow. + +@publishedAll +@released +*/ +inline TInt RHeap::MaxLength() const + {return iMaxLength;} + +inline void RHeap::operator delete(TAny*, TAny*) +/** +Called if constructor issued by operator new(TUint aSize, TAny* aBase) throws exception. +This is dummy as corresponding new operator does not allocate memory. +*/ + {} + + +inline TUint8* RHeap::Base() const +/** +Gets a pointer to the start of the heap. + +Note that because of the small space overhead incurred by all allocated cells, +no cell will have the same address as that returned by this function. + +@return A pointer to the base of the heap. +*/ + {return iBase;} + + + + +inline TInt RHeap::Size() const +/** +Gets the current size of the heap. + +This is the total number of bytes committed by the host chunk. +It is the requested size rounded up by page size minus the size of RHeap object(116 bytes) +minus the cell alignment overhead as shown: + +Size = (Rounded committed size - Size of RHeap - Cell Alignment Overhead). + +The cell alignment overhead varies between release builds and debug builds. + +Note that this value is always greater than the total space available across all allocated cells. + +@return The size of the heap. + +@see Rheap::Available( ) +*/ + {return iTop-iBase;} + + + + +inline TInt RHeap::Align(TInt a) const +/** +@internalComponent +*/ + {return _ALIGN_UP(a, iAlign);} + + + + +inline const TAny* RHeap::Align(const TAny* a) const +/** +@internalComponent +*/ + {return (const TAny*)_ALIGN_UP((TLinAddr)a, iAlign);} + + + + +inline TBool RHeap::IsLastCell(const SCell* aCell) const +/** +@internalComponent +*/ + {return (((TUint8*)aCell) + aCell->len) == iTop;} + + + + +#ifndef __KERNEL_MODE__ +inline void RHeap::Lock() const +/** +@internalComponent +*/ + {((RFastLock&)iLock).Wait();} + + + + +inline void RHeap::Unlock() const +/** +@internalComponent +*/ + {((RFastLock&)iLock).Signal();} + + +inline TInt RHeap::ChunkHandle() const +/** +@internalComponent +*/ + { + return iChunkHandle; + } +#endif + + + + +// Class TRefByValue +template +inline TRefByValue::TRefByValue(T &aRef) + : iRef(aRef) +/** +Constructs this value reference for the specified referenced object. + +@param aRef The referenced object. +*/ + {} + + + + +template +inline TRefByValue::operator T &() +/** +Gets a reference to the object encapsulated inside this value reference. +*/ + {return(iRef);} + + + + +/** +Creates the logical channel. + +@param aDevice The name of the logical device for which the channel + is to be constructed. This is the name by which + the LDD factory object, i.e. the instance of + the DLogicalDevice derived class, is known. +@param aVer The required version of the logical device. The driver + normally checks this against the version of the logical + channel, returning KErrNotSupported if the logical channel + is not compatible. +@param aUnit A unit of the device. This argument only has meaning if + the flag KDeviceAllowUnit is set in the iParseMask data + member of the LDD factory object. +@param aDriver A pointer to a descriptor containing the name of + a physical device. This is the name by which the PDD + factory object, i.e. the instance of the DPhysicalDevice + derived class, is known. + This is NULL, if no explicit name is to be supplied, or + the logical device does not require an accompanying physical + device. +@param aInfo A pointer to an explicit 8-bit descriptor containing extra + information for the physical device. This argument only has + meaning if the KDeviceAllowInfo flag is set in the iParseMask + data member of the LDD factory object. +@param aType An enumeration whose enumerators define the ownership of + this handle. If not explicitly specified, EOwnerProcess is + taken as default. +@param aTransferable If false, the channel is created as an object which is + local/private to the current process. + If true, the channel is an object which may be shared with + other processes using the IPC mechanisms for handle passing. + +@return KErrNone, if successful; otherwise one of the other system wide + error codes. +*/ +inline TInt RBusLogicalChannel::DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TOwnerType aType, TBool aTransferable) + { return DoCreate(aDevice, aVer, aUnit, aDriver, aInfo, (TInt)aType | (aTransferable?KCreateProtectedObject:0) ); } + + + + +// Class TChar +inline TChar::TChar() +/** +Default constructor. + +Constructs this character object with an undefined value. +*/ + {} + + + + +inline TChar::TChar(TUint aChar) + : iChar(aChar) +/** +Constructs this character object and initialises it with the specified value. + +@param aChar The initialisation value. +*/ + {} + + + + +inline TChar& TChar::operator-=(TUint aChar) +/** +Subtracts an unsigned integer value from this character object. + +This character object is changed by the operation. + +@param aChar The value to be subtracted. + +@return A reference to this character object. +*/ + {iChar-=aChar;return(*this);} + + + + +inline TChar& TChar::operator+=(TUint aChar) +/** +Adds an unsigned integer value to this character object. + +This character object is changed by the operation. + +@param aChar The value to be added. + +@return A reference to this character object. +*/ + {iChar+=aChar;return(*this);} + + + + +inline TChar TChar::operator-(TUint aChar) +/** +Gets the result of subtracting an unsigned integer value from this character +object. + +This character object is not changed. + +@param aChar The value to be subtracted. + +@return A character object whose value is the result of the subtraction + operation. +*/ + {return(iChar-aChar);} + + + + +inline TChar TChar::operator+(TUint aChar) +/** +Gets the result of adding an unsigned integer value to this character object. + +This character object is not changed. + +@param aChar The value to be added. + +@return A character object whose value is the result of the addition operation. +*/ + {return(iChar+aChar);} + + + + +inline TChar::operator TUint() const +/** +Gets the value of the character as an unsigned integer. + +The operator casts a TChar to a TUint, returning the TUint value wrapped by +this character object. +*/ + {return(iChar);} + + + + +// Class TDesC8 +inline TBool TDesC8::operator<(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is less than the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if greater than or equal, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)<0);} + + + + +inline TBool TDesC8::operator<=(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is less than or equal to the +specified descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if less than or equal, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)<=0);} + + + + +inline TBool TDesC8::operator>(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is greater than the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if greater than, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)>0);} + + + + +inline TBool TDesC8::operator>=(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is greater than or equal to the +specified descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if greater than, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)>=0);} + + + + +inline TBool TDesC8::operator==(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is equal to the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if equal, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)==0);} + + + + +inline TBool TDesC8::operator!=(const TDesC8 &aDes) const +/** +Determines whether this descriptor's data is not equal to the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 8-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if not equal, false otherwise. + +@see TDesC8::Compare +*/ + {return(Compare(aDes)!=0);} + + + + +inline const TUint8 &TDesC8::operator[](TInt anIndex) const +/** +Gets a reference to a single data item within this descriptor's data. + +@param anIndex The position of the individual data item within the descriptor's + data. This is an offset value; a zero value refers to the + leftmost data position. + +@return A reference to the data item. + +@panic USER 21, if anIndex is negative or greater than or equal to the current + length of the descriptor. +*/ + {return(AtC(anIndex));} + + + + +inline TInt TDesC8::Length() const +/** +Gets the length of the data. + +This is the number of 8-bit values or data items represented by the descriptor. + +@return The length of the data represented by the descriptor. +*/ + {return(iLength&KMaskDesLength8);} + + + + +inline TInt TDesC8::Size() const +/** +Gets the size of the data. + +This is the number of bytes occupied by the data represented by the descriptor. + +@return The size of the data represented by the descriptor. +*/ + {return(Length());} + + + + +inline void TDesC8::DoSetLength(TInt aLength) + {iLength=(iLength&(~KMaskDesLength8))|aLength;} + + + + +// Class TPtrC8 +inline void TPtrC8::Set(const TUint8 *aBuf,TInt aLength) +/** +Sets the 8-bit non-modifiable pointer descriptor to point to the specified +location in memory, whether in RAM or ROM. + +The length of the descriptor is set to the specified length. + +@param aBuf A pointer to the location that the descriptor is to represent. +@param aLength The length of the descriptor. This value must be non-negative. + +@panic USER 29, if aLength is negative. +*/ + {new(this) TPtrC8(aBuf,aLength);} + + + + +inline void TPtrC8::Set(const TDesC8 &aDes) +/** +Sets the 8-bit non-modifiable pointer descriptor from the specified descriptor. + +It is set to point to the same data and is given the same length. + +@param aDes A reference to an 8-bit non-modifiable descriptor. +*/ + {new(this) TPtrC8(aDes);} + + + + +inline void TPtrC8::Set(const TPtrC8& aPtr) +/** +Sets the 8-bit non-modifiable pointer descriptor from the specified +non-modifiable pointer descriptor. + +It is set to point to the same data and is given the same length. + +@param aPtr A reference to an 8-bit non-modifiable pointer descriptor. +*/ + {new(this) TPtrC8(aPtr);} + + + + + +// class TBufCBase8 +inline TPtr8 TBufCBase8::DoDes(TInt aMaxLength) + {return TPtr8(*this,aMaxLength);} + + + + +// Template class TBufC8 +template +inline TBufC8::TBufC8() + : TBufCBase8() +/** +Constructs an empty 8-bit non-modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area which +is created as part of the buffer descriptor object. + +Data can, subsequently, be assigned into this buffer descriptor using the +assignment operators. + +@see TBufC8::operator= +*/ + {} + + + + +template +inline TBufC8::TBufC8(const TUint8 *aString) + : TBufCBase8(aString,S) +/** +Constructs the 8-bit non-modifiable buffer descriptor from a zero terminated +string. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +The string, excluding the zero terminator, is copied into this buffer descriptor's +data area. The length of this buffer descriptor is set to the length of the +string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 20, if the length of the string, excluding the zero terminator, is + greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TBufC8::TBufC8(const TDesC8 &aDes) + : TBufCBase8(aDes,S) +/** +Constructs the 8-bit non-modifiable buffer descriptor from any +existing descriptor. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +Data is copied from the source descriptor into this buffer descriptor and +the length of this buffer descriptor is set to the length of the +source descriptor. + +@param aDes The source 8-bit non-modifiable descriptor. + +@panic USER 20, if the length of the source descriptor is + greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TBufC8 &TBufC8::operator=(const TUint8 *aString) +/** +Copies data into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this descriptor. + +@panic USER 23, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString,S);return(*this);} + + + + +template +inline TBufC8 &TBufC8::operator=(const TDesC8 &aDes) +/** +Copies data into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit non-modifiable descriptor. + +@return A reference to this descriptor. + +@panic USER 23, if the length of the descriptor aDes is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aDes,S);return(*this);} + + + + +template +inline TPtr8 TBufC8::Des() +/** +Creates and returns an 8-bit modifiable pointer descriptor for the data +represented by this 8-bit non-modifiable buffer descriptor. + +The content of a non-modifiable buffer descriptor normally cannot be altered, +other than by complete replacement of the data. Creating a modifiable pointer +descriptor provides a way of changing the data. + +The modifiable pointer descriptor is set to point to this non-modifiable buffer +descriptor's data. + +The length of the modifiable pointer descriptor is set to the length of this +non-modifiable buffer descriptor. + +The maximum length of the modifiable pointer descriptor is set to the value +of the integer template parameter. + +When data is modified through this new pointer descriptor, the lengths of +both it and this constant buffer descriptor are changed. + +@return An 8-bit modifiable pointer descriptor representing the data in this + 8-bit non-modifiable buffer descriptor. +*/ + {return DoDes(S);} + + + + +#ifndef __KERNEL_MODE__ +// Class HBufC8 +inline HBufC8 &HBufC8::operator=(const HBufC8 &aLcb) +/** +Copies data into this 8-bit heap descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +Note that the maximum length of this (target) descriptor is the length +of the descriptor buffer in the allocated host heap cell; this may be greater +than the maximum length specified when this descriptor was created or +last re-allocated. + +@param aLcb The source 8-bit heap descriptor. + +@return A reference to this 8-bit heap descriptor. + +@panic USER 23, if the length of the descriptor aLcb is greater than the + maximum length of this (target) descriptor +*/ + {return *this=static_cast(aLcb);} + + + + +// Class RBuf8 +inline RBuf8& RBuf8::operator=(const TUint8* aString) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline RBuf8& RBuf8::operator=(const TDesC8& aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit non-modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline RBuf8& RBuf8::operator=(const RBuf8& aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 8-bit buffer descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +/** +Creates an 8-bit resizable buffer descriptor that has been initialised with +data from the specified read stream; leaves on failure. + +Data is assigned to the new descriptor from the specified stream. +This variant assumes that the stream contains the length of the data followed +by the data itself. + +The function is implemented by calling the HBufC8::NewL(RReadStream&,TInt) +variant and then assigning the resulting heap descriptor using +the RBuf8::Assign(HBufC8*) variant. The comments that describe +the HBufC8::NewL() variant also apply to this RBuf8::CreateL() function. + +The function may leave with one of the system-wide error codes, specifically +KErrOverflow, if the length of the data as read from the stream is greater than +the upper limit as specified by the aMaxLength parameter. + +@param aStream The stream from which the data length and the data to be + assigned to the new descriptor, are taken. +@param aMaxLength The upper limit on the length of data that the descriptor is + to represent. The value of this parameter must be non-negative + otherwise the underlying function will panic. +*/ +inline void RBuf8::CreateL(RReadStream &aStream,TInt aMaxLength) + { + Assign(HBufC8::NewL(aStream,aMaxLength)); + } +#endif + + + + +// Class TDes8 +inline TDes8 &TDes8::operator=(const TUint8 *aString) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this, the target descriptor. + +@panic USER 23, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline TDes8 &TDes8::operator=(const TDesC8 &aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit non-modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 23, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TDes8 &TDes8::operator=(const TDes8 &aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 23, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TDes8 &TDes8::operator+=(const TDesC8 &aDes) +/** +Appends data onto the end of this descriptor's data and returns a reference +to this descriptor. + +The length of this descriptor is incremented to reflect the new content. + +@param aDes An-8 bit non-modifiable descriptor whose data is to be appended. + +@return A reference to this descriptor. + +@panic USER 23, if the resulting length of this descriptor is greater than its + maximum length. +*/ + {Append(aDes);return(*this);} + + + + +inline const TUint8 &TDes8::operator[](TInt anIndex) const +/** +Gets a const reference to a single data item within this descriptor's data. + +@param anIndex The position of the data item within this descriptor's data. + This is an offset value; a zero value refers to the leftmost + data position. + +@return A const reference to the data item at the specified position. + +@panic USER 21, if anIndex is negative or is greater than or equal to the + current length of this descriptor. +*/ + {return(AtC(anIndex));} + + + + +inline TUint8 &TDes8::operator[](TInt anIndex) +/** +Gets a non-const reference to a single data item within this descriptor's +data. + +@param anIndex The position of the data item within this descriptor's data. + This is an offset value; a zero value refers to the leftmost + data position. + +@return A non-const reference to the data item at the specified position. + +@panic USER 21, if anIndex is negative or is greater than or equal to the + current length of this descriptor. +*/ + {return((TUint8 &)AtC(anIndex));} + + + + +inline TInt TDes8::MaxLength() const +/** +Gets the maximum length of the descriptor. + +This is the upper limit for the number of 8-bit values or data items that +the descriptor can represent. + +@return The maximum length of data that the descriptor can represent. +*/ + {return(iMaxLength);} + + + + +inline TInt TDes8::MaxSize() const +/** +Gets the maximum size of the descriptor. + +This is the upper limit for the number of bytes which the data represented by +the descriptor can occupy. + +@return The maximum size of the descriptor data. +*/ + {return(iMaxLength);} + + + + +inline TUint8 * TDes8::WPtr() const + {return((TUint8 *)Ptr());} + + + + +// Class TPtr8 +inline TPtr8 &TPtr8::operator=(const TUint8 *aString) +/** +Copies data into this 8-bit modifiable pointer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this 8-bit modifiable pointer descriptor. + +@panic USER 23, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline TPtr8 &TPtr8::operator=(const TDesC8 &aDes) +/** +Copies data into this 8-bit modifiable pointer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit modifiable pointer descriptor whose data is to be copied + into this descriptor. + +@return A reference to this 8-bit modifiable pointer descriptor. + +@panic USER 23, if the length of aDes is greater than the maximum + length of this descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TPtr8 &TPtr8::operator=(const TPtr8 &aDes) +/** +Copies data into this 8-bit modifiable pointer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8-bit modifiable pointer descriptor whose data is to be copied + into this descriptor. + +@return A reference to this 8-bit modifiable pointer descriptor. + +@panic USER 23, if the length of aDes is greater than the maximum + length of this descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline void TPtr8::Set(TUint8 *aBuf,TInt aLength,TInt aMaxLength) +/** +Sets the 8-bit modifiable pointer descriptor to point to the specified location +in memory, whether in RAM or ROM. + +The length of the descriptor and its maximum length are set to the specified +values. + +@param aBuf A pointer to the location that the descriptor is to represent. +@param aLength The length of the descriptor. +@param aMaxLength The maximum length of the descriptor. + +@panic USER 20, if aLength is negative or is greater than the maximum length of + this descriptor. +@panic USER 30, if aMaxLength is negative. +*/ + {new(this) TPtr8(aBuf,aLength,aMaxLength);} + + + + +inline void TPtr8::Set(const TPtr8 &aPtr) +/** +Sets the 8-bit modifiable pointer descriptor from an existing 8-bit modifiable +pointer descriptor. + +It is set to point to the same data, is given the same length and the same +maximum length as the source pointer descriptor. + +@param aPtr The source 8-bit modifiable pointer descriptor. +*/ + {new(this) TPtr8(aPtr);} + + + + +// Template class TBuf8 +template +inline TBuf8::TBuf8() + : TBufBase8(S) +/** +Constructs an empty 8-bit modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area that is created +as part of the object, and defines the descriptor's maximum length. +*/ + {} + + + + +template +inline TBuf8::TBuf8(TInt aLength) + : TBufBase8(aLength,S) +/** +Constructs an empty 8-bit modifiable buffer descriptor and sets the its length +to the specified value. + +No data is assigned to the descriptor. + +The integer template parameter determines the size of the data area that is created +as part of the object, and defines the descriptor's maximum length. + +@param aLength The length of this modifiable buffer descriptor. + +@panic USER 20, if aLength is negative or is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf8::TBuf8(const TUint8 *aString) + : TBufBase8(aString,S) +/** +Constructs the 8-bit modifiable buffer descriptor from a +zero terminated string. + +The integer template parameter determines the size of the data area that +is created as part of the object, and defines the descriptor's maximum length. + +The string, excluding the zero terminator, is copied into this buffer +descriptor's data area. The length of this buffer descriptor is set to the +length of the string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf8::TBuf8(const TDesC8 &aDes) + : TBufBase8(aDes,S) +/** +Constructs the 8-bit modifiable buffer descriptor from any existing +8-bit descriptor. + +The integer template parameter determines the size of the data area created +as part of this object and defines the descriptor's maximum length. + +Data is copied from the source descriptor into this modifiable buffer +descriptor and the length of this modifiable buffer descriptor is set to +the length of the source descriptor. + +@param aDes The source 8-bit non-modifiable descriptor. + +@panic USER 23, if the length of the source descriptor is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf8 &TBuf8::operator=(const TUint8 *aString) +/** +Copies data into this 8-bit modifiable buffer descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this 8-bit modifiable buffer descriptor. + +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +template +inline TBuf8 &TBuf8::operator=(const TDesC8 &aDes) +/** +Copies data into this 8-bit modifiable buffer descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8 bit non-modifiable descriptor. + +@return A reference to this 8-bit modifiable buffer descriptor. + +@panic USER 23, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +template +inline TBuf8& TBuf8::operator=(const TBuf8& aBuf) +/** +Copies data into this 8-bit modifiable buffer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aBuf The source 8-bit modifiable buffer descriptor with the same + template value. + +@return A reference to this 8-bit modifiable buffer descriptor. +*/ + {Copy(aBuf);return *this;} + + + + +// Template class TAlignedBuf8 +template +inline TAlignedBuf8::TAlignedBuf8() + : TBufBase8(S) +/** +Constructs an empty 8-bit modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area that is created +as part of the object, and defines the descriptor's maximum length. +*/ + {} + + + + +template +inline TAlignedBuf8::TAlignedBuf8(TInt aLength) + : TBufBase8(aLength,S) +/** +Constructs an empty 8-bit modifiable buffer descriptor and sets the its length +to the specified value. + +No data is assigned to the descriptor. + +The integer template parameter determines the size of the data area that is created +as part of the object, and defines the descriptor's maximum length. + +@param aLength The length of this modifiable buffer descriptor. + +@panic USER 20, if aLength is negative or is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TAlignedBuf8::TAlignedBuf8(const TUint8 *aString) + : TBufBase8(aString,S) +/** +Constructs the 8-bit modifiable buffer descriptor from a +zero terminated string. + +The integer template parameter determines the size of the data area that +is created as part of the object, and defines the descriptor's maximum length. + +The string, excluding the zero terminator, is copied into this buffer +descriptor's data area. The length of this buffer descriptor is set to the +length of the string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TAlignedBuf8::TAlignedBuf8(const TDesC8 &aDes) + : TBufBase8(aDes,S) +/** +Constructs the 8-bit modifiable buffer descriptor from any existing +8-bit descriptor. + +The integer template parameter determines the size of the data area created +as part of this object and defines the descriptor's maximum length. + +Data is copied from the source descriptor into this modifiable buffer +descriptor and the length of this modifiable buffer descriptor is set to +the length of the source descriptor. + +@param aDes The source 8-bit non-modifiable descriptor. + +@panic USER 23, if the length of the source descriptor is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TAlignedBuf8 &TAlignedBuf8::operator=(const TUint8 *aString) +/** +Copies data into this 8-bit modifiable buffer descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this 8-bit modifiable buffer descriptor. + +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +template +inline TAlignedBuf8 &TAlignedBuf8::operator=(const TDesC8 &aDes) +/** +Copies data into this 8-bit modifiable buffer descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes An 8 bit non-modifiable descriptor. + +@return A reference to this 8-bit modifiable buffer descriptor. + +@panic USER 23, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +template +inline TAlignedBuf8& TAlignedBuf8::operator=(const TAlignedBuf8& aBuf) +/** +Copies data into this 8-bit modifiable buffer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aBuf The source 8-bit modifiable buffer descriptor with the same + template value. + +@return A reference to this 8-bit modifiable buffer descriptor. +*/ + {Copy(aBuf);return *this;} + + + + +// Template class TLitC8 +template +inline const TDesC8* TLitC8::operator&() const +/** +Returns a const TDesC8 type pointer. + +@return A descriptor type pointer to this literal. +*/ + {return REINTERPRET_CAST(const TDesC8*,this);} + + + + +template +inline const TDesC8& TLitC8::operator()() const +/** +Returns a const TDesC8 type reference. + +@return A descriptor type reference to this literal +*/ + {return *operator&();} + + + + +template +inline TLitC8::operator const TDesC8&() const +/** +Invoked by the compiler when a TLitC8 type is passed to a function +which is prototyped to take a const TDesC8& type. +*/ + {return *operator&();} + + + +template +inline TLitC8::operator const __TRefDesC8() const +/** +Invoked by the compiler when a TLitC8 type is passed to a function +which is prototyped to take a const TRefByValue type. + +@see __TRefDesC8 +*/ + {return *operator&();} + + + + +#ifndef __KERNEL_MODE__ +// Class TDesC16 +inline TBool TDesC16::operator<(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is less than the specified descriptor's +data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non-modifable descriptor whose data is to be compared + with this descriptor's data. + +@return True if less than, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)<0);} + + + + +inline TBool TDesC16::operator<=(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is less than or equal +to the specified descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non- modifiable descriptor whose data is to be compared + with this descriptor's data. + +@return True if less than or equal, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)<=0);} + + + + +inline TBool TDesC16::operator>(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is greater than the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non-modifiable descriptor whose data is to be compared + with this descriptor's data. + +@return True if greater than, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)>0);} + + + + +inline TBool TDesC16::operator>=(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is greater than or equal to the +specified descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non-modifiable descriptor whose data is to be compared + with this descriptor's data. + +@return True if greater than or equal, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)>=0);} + + + + +inline TBool TDesC16::operator==(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is equal to the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non-modifiable descriptor whose data is to be compared + with this descriptor's data. + +@return True if equal, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)==0);} + + + + +inline TBool TDesC16::operator!=(const TDesC16 &aDes) const +/** +Determines whether this descriptor's data is not equal to the specified +descriptor's data. + +The comparison is implemented using the Compare() member function. + +@param aDes The 16-bit non-modifiable descriptor whose data is to be compared + with this descriptor's data. + +@return True if not equal, false otherwise. + +@see TDesC16::Compare +*/ + {return(Compare(aDes)!=0);} + + + + +inline const TUint16 &TDesC16::operator[](TInt anIndex) const +/** +Gets a reference to a single data item within this descriptor's data. + +@param anIndex The position of the individual data item within the descriptor's + data. This is an offset value; a zero value refers to the + leftmost data position. + +@return A reference to the data item. + +@panic USER 9, if anIndex is negative or greater than or equal to the current + length of the descriptor. +*/ + {return(AtC(anIndex));} + + + + +inline TInt TDesC16::Length() const +/** +Gets the length of the data. + +This is the number of 16-bit values or data items represented by the descriptor. + +@return The length of the data represented by the descriptor. +*/ + {return(iLength&KMaskDesLength16);} + + + + +inline TInt TDesC16::Size() const +/** +Gets the size of the data. + +This is the number of bytes occupied by the data represented by the descriptor. + +@return The size of the data represented by the descriptor. This is always + twice the length. + */ + {return(Length()<<1);} + + + + +inline void TDesC16::DoSetLength(TInt aLength) + {iLength=(iLength&(~KMaskDesLength16))|aLength;} + + + + +// Class TPtrC16 +inline void TPtrC16::Set(const TUint16 *aBuf,TInt aLength) +/** +Sets the 16-bit non-modifiable pointer descriptor to point to the specified +location in memory, whether in RAM or ROM. + +The length of the descriptor is set to the specified length. + +@param aBuf A pointer to the location that the descriptor is to represent. +@param aLength The length of the descriptor. This value must be non-negative + +@panic USER 17, if aLength is negative. +*/ + {new(this) TPtrC16(aBuf,aLength);} + + + + +inline void TPtrC16::Set(const TDesC16 &aDes) +/** +Sets the 16-bit non-modifiable pointer descriptor from the specified descriptor. + +It is set to point to the same data and is given the same length. + +@param aDes A reference to a 16-bit non-modifiable descriptor +*/ + {new(this) TPtrC16(aDes);} + + + + +inline void TPtrC16::Set(const TPtrC16& aPtr) + {new(this) TPtrC16(aPtr);} + + + + +// class TBufCBase16 +inline TPtr16 TBufCBase16::DoDes(TInt aMaxLength) + {return TPtr16(*this,aMaxLength);} + + + + +// Template class TBufC16 +template +inline TBufC16::TBufC16() + : TBufCBase16() +/** +Constructs an empty 16-bit non-modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area which +is created as part of the buffer descriptor object. + +Data can, subsequently, be assigned into this buffer descriptor using the +assignment operators. + +@see TBufC16::operator= +*/ + {} + + + + +template +inline TBufC16::TBufC16(const TUint16 *aString) + : TBufCBase16(aString,S) +/** +Constructs the 16-bit non-modifiable buffer descriptor from a zero terminated +string. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +The string, excluding the zero terminator, is copied into this buffer descriptor's +data area. The length of this buffer descriptor is set to the length of the +string, excluding the zero terminator. + +@panic USER 8, if the length of the string, excluding the zero terminator, is + greater than the value of the integer template parameter. + +@param aString A pointer to a zero terminated string. +*/ + {} + + + + +template +inline TBufC16::TBufC16(const TDesC16 &aDes) + : TBufCBase16(aDes,S) +/** +Constructs the 16-bit non-modifiable buffer descriptor from any +existing descriptor. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +Data is copied from the source descriptor into this buffer descriptor and +the length of this buffer descriptor is set to the length of the +source descriptor. + +@param aDes The source 16-bit non-modifiable descriptor. + +@panic USER 8, if the length of the source descriptor is + greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TBufC16 &TBufC16::operator=(const TUint16 *aString) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString,S);return(*this);} + + + + +template +inline TBufC16 &TBufC16::operator=(const TDesC16 &aDes) +/** +Copies data into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit non-modifiable descriptor. + +@panic USER 11, if the length of the descriptor aDes is + greater than the maximum length of this (target) descriptor. + +@return A reference to this descriptor. +*/ + {Copy(aDes,S);return(*this);} + + + + +template +inline TPtr16 TBufC16::Des() +/** +Creates and returns a 16-bit modifiable pointer descriptor for the data +represented by this 16-bit non-modifiable buffer descriptor. + +The content of a non-modifiable buffer descriptor normally cannot be altered, +other than by complete replacement of the data. Creating a modifiable pointer +descriptor provides a way of changing the data. + +The modifiable pointer descriptor is set to point to this non-modifiable buffer +descriptor's data. + +The length of the modifiable pointer descriptor is set to the length of this +non-modifiable buffer descriptor. + +The maximum length of the modifiable pointer descriptor is set to the value +of the integer template parameter. + +When data is modified through this new pointer descriptor, the lengths of +both it and this constant buffer descriptor are changed. + +@return A 16-bit modifiable pointer descriptor representing the data in this + 16-bit non-modifiable buffer descriptor. +*/ + {return(DoDes(S));} + + + + +#ifndef __KERNEL_MODE__ +// Class HBufC16 +inline HBufC16 &HBufC16::operator=(const HBufC16 &aLcb) +/** +Copies data into this 16-bit heap descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +Note that the maximum length of this (target) descriptor is the length +of the descriptor buffer in the allocated host heap cell; this may be greater +than the maximum length specified when this descriptor was created or +last re-allocated. + +@param aLcb The source 16-bit heap descriptor. + +@return A reference to this 16-bit heap descriptor. + +@panic USER 11, if the length of the descriptor aLcb is greater than the + maximum length of this (target) descriptor +*/ + {return *this=static_cast(aLcb);} +#endif + + + + +// Class TDes16 +inline TDes16 &TDes16::operator=(const TUint16 *aString) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline TDes16 &TDes16::operator=(const TDesC16 &aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit non-modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TDes16 &TDes16::operator=(const TDes16 &aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TDes16 &TDes16::operator+=(const TDesC16 &aDes) +/** +Appends data onto the end of this descriptor's data and returns a reference +to this descriptor. + +The length of this descriptor is incremented to reflect the new content. + +@param aDes A 16-bit non-modifiable descriptor whose data is to be appended. + +@return A reference to this descriptor. + +@panic USER 11, if the resulting length of this descriptor is greater than its + maximum length. +*/ + {Append(aDes);return(*this);} + + + + +inline const TUint16 &TDes16::operator[](TInt anIndex) const +/** +Gets a const reference to a single data item within this descriptor's data. + +@param anIndex The position the data item within this descriptor's data. This +is an offset value; a zero value refers to the leftmost data position. + +@return A const reference to the data item at the specified position. + +@panic USER 9, if anIndex is negative or is greater than or equal to the + current length of this descriptor. +*/ + {return(AtC(anIndex));} + + + + +inline TUint16 &TDes16::operator[](TInt anIndex) +/** +Gets a non-const reference to a single data item within this descriptor's +data. + +@param anIndex The position of the data item within this descriptor's data. + This is an offset value; a zero value refers to the leftmost + data position. + +@return A non-const reference to the data item at the specified position. + +@panic USER 9, if anIndex is negative or is greater than or equal to the + current length of this descriptor. +*/ + {return((TUint16 &)AtC(anIndex));} + + + + +inline TInt TDes16::MaxLength() const +/** +Gets the maximum length of the descriptor. + +This is the upper limit for the number of 16-bit values or data items that +the descriptor can represent. + +@return The maximum length of data that the descriptor can represent. +*/ + {return(iMaxLength);} + + + + +inline TInt TDes16::MaxSize() const +/** +Gets the maximum size of the descriptor. + +This is the upper limit for the number of bytes which the data represented by +the descriptor can occupy. + +@return The maximum size of the descriptor data. +*/ + {return(iMaxLength<<1);} + + + + +inline TUint16 * TDes16::WPtr() const + {return((TUint16 *)Ptr());} + + + + +// Class TPtr16 +inline TPtr16 &TPtr16::operator=(const TUint16 *aString) +/** +Copies data into this 16-bit modifiable pointer descriptor replacing +any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this 16-bit modifiable pointer descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline TPtr16 &TPtr16::operator=(const TDesC16 &aDes) +/** +Copies data into this 16-bit modifiable pointer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit non-modifiable descriptor whose data is to be copied + into this descriptor. + +@return A reference to this 16-bit modifiable pointer descriptor. + +@panic USER 11, if the length of aDes is greater than the maximum + length of this descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline TPtr16 &TPtr16::operator=(const TPtr16 &aDes) +/** +Copies data into this 16-bit modifiable pointer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit modifiable pointer descriptor whose data is to be copied + into this descriptor. + +@return A reference to this 16-bit modifiable pointer descriptor. + +@panic USER 11, if the length of aDes is greater than the maximum + length of this descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline void TPtr16::Set(TUint16 *aBuf,TInt aLength,TInt aMaxLength) +/** +Sets the 16-bit modifiable pointer descriptor to point to the specified location +in memory, whether in RAM or ROM. + +The length of the descriptor and its maximum length are set to the specified +values. + +@param aBuf A pointer to the location that the descriptor is to represent. +@param aLength The length of the descriptor. +@param aMaxLength The maximum length of the descriptor. + +@panic USER 8, if aLength is negative or is greater than the maximum length of + this descriptor. +@panic USER 18, if aMaxLength is negative. +*/ + {new(this) TPtr16(aBuf,aLength,aMaxLength);} + + + + +inline void TPtr16::Set(const TPtr16 &aPtr) +/** +Sets the 16-bit modifiable pointer descriptor from an existing +16-bit modifiable pointer descriptor. + +It is set to point to the same data, is given the same length and the same +maximum length as the source pointer descriptor. + +@param aPtr The source 16-bit modifiable pointer descriptor. +*/ + {new(this) TPtr16(aPtr);} + + + + +// Template class TBuf16 +template +inline TBuf16::TBuf16() + : TBufBase16(S) +/** +Constructs an empty 16-bit modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area created +as part of the object and defines the descriptor's maximum length. +*/ + {} + + + + +template +inline TBuf16::TBuf16(TInt aLength) + : TBufBase16(aLength,S) +/** +Constructs an empty 16-bit modifiable buffer descriptor and sets the its length +to the specified value. + +No data is assigned to the descriptor. + +The integer template parameter defines the size of the data area created as +part of the object and defines the descriptor's maximum length. + +@param aLength The length of this modifiable buffer descriptor. + +@panic USER 8, if aLength is negative or is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf16::TBuf16(const TUint16 *aString) + : TBufBase16(aString,S) +/** +Constructs the 16-bit modifiable buffer descriptor from +a zero terminated string. + +The integer template parameter determines the size of the data area that is +created as part of this object, and defines the descriptor's maximum length. + +The string, excluding the zero terminator, is copied into this buffer +descriptor's data area. The length of this buffer descriptor is set to the +length of the string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 11, if the length of the string, excluding the zero terminator, + is greater than the value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf16::TBuf16(const TDesC16 &aDes) + : TBufBase16(aDes,S) +/** +Constructs the 16-bit modifiable buffer descriptor from any existing +16-bit descriptor. + +The integer template parameter determines the size of the data area created +as part of this object and defines the descriptor's maximum length. + +Data is copied from the source descriptor into this modifiable buffer descriptor +and the length of this modifiable buffer descriptor is set to the length of +the source descriptor. + +@param aDes The source 16-bit non-modifiable descriptor. + +@panic USER 11, if the length of the source descriptor is greater than the + value of the integer template parameter. +*/ + {} + + + + +template +inline TBuf16 &TBuf16::operator=(const TUint16 *aString) +/** +Copies data into this 16-bit modifiable buffer descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, + is greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +template +inline TBuf16 &TBuf16::operator=(const TDesC16 &aDes) +/** +Copies data into this 16-bit modifiable descriptor, replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit non-modifiable descriptor. + +@return A reference to this descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +template +inline TBuf16& TBuf16::operator=(const TBuf16& aBuf) +/** +Copies data into this 16-bit modifiable buffer descriptor replacing any +existing data. + +The length of this descriptor is set to reflect the new data. + +@param aBuf The source 16-bit modifiable buffer descriptor with the same + template value. + +@return A reference to this 16-bit modifiable buffer descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aBuf);return *this;} + + +// Class RBuf16 +inline RBuf16& RBuf16::operator=(const TUint16* aString) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, is + greater than the maximum length of this (target) descriptor. +*/ + {Copy(aString);return(*this);} + + + + +inline RBuf16& RBuf16::operator=(const TDesC16& aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit non-modifiable descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +inline RBuf16& RBuf16::operator=(const RBuf16& aDes) +/** +Copies data into this descriptor replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A 16-bit buffer descriptor. + +@return A reference to this, the target descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor. +*/ + {Copy(aDes);return(*this);} + + + + +/** +Creates a 16-bit resizable buffer descriptor that has been initialised with +data from the specified read stream; leaves on failure. + +Data is assigned to the new descriptor from the specified stream. +This variant assumes that the stream contains the length of the data followed +by the data itself. + +The function is implemented by calling the HBufC16::NewL(RReadStream&,TInt) +variant and then assigning the resulting heap descriptor using +the RBuf16::Assign(HBufC16*) variant. The comments that describe +the HBufC16::NewL() variant also apply to this RBuf16::CreateL() function. + +The function may leave with one of the system-wide error codes, specifically +KErrOverflow, if the length of the data as read from the stream is greater than +the upper limit as specified by the aMaxLength parameter. + +@param aStream The stream from which the data length and the data to be + assigned to the new descriptor, are taken. +@param aMaxLength The upper limit on the length of data that the descriptor is + to represent. The value of this parameter must be non-negative + otherwise the underlying function will panic. +*/ +inline void RBuf16::CreateL(RReadStream &aStream,TInt aMaxLength) + { + Assign(HBufC16::NewL(aStream,aMaxLength)); + } + + +// Template class TLitC16 +template +inline const TDesC16* TLitC16::operator&() const +/** +Returns a const TDesC16 type pointer. + +@return A descriptor type pointer to this literal. +*/ + {return REINTERPRET_CAST(const TDesC16*,this);} + + + + +template +inline const TDesC16& TLitC16::operator()() const +/** +Returns a const TDesC16 type reference. + +@return A descriptor type reference to this literal +*/ + {return *operator&();} + + + + +template +inline TLitC16::operator const TDesC16&() const +/** +Invoked by the compiler when a TLitC16 type is passed to a function +which is prototyped to take a const TDesC16& type. +*/ + {return *operator&();} + + + + +template +inline TLitC16::operator const __TRefDesC16() const +/** +Invoked by the compiler when a TLitC16 type is passed to a function +which is prototyped to take a const TRefByValue type. + +@see __TRefDesC16 +*/ + {return *operator&();} +#endif //__KERNEL_MODE__ + + + + +// Template class TBufC +#if defined(_UNICODE) && !defined(__KERNEL_MODE__) +template +inline TBufC::TBufC() + : TBufCBase16() +/** +Constructs an empty build independent non-modifiable buffer descriptor. + +It contains no data. + +The integer template parameter determines the size of the data area which +is created as part of the buffer descriptor object. + +Data can, subsequently, be assigned into this buffer descriptor using the +assignment operators. + +@see TBufC::operator= +*/ + {} + + + + +template +inline TBufC::TBufC(const TText *aString) + : TBufCBase16(aString,S) +/** +Constructs a build independent non-modifiable +buffer descriptor from a zero terminated string. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +The string, excluding the zero terminator, is copied into this buffer descriptor's +data area. The length of this buffer descriptor is set to the length of the +string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 8, if the length of the string, excluding the zero terminator, is + greater than the value of the integer template parameter for + the 16-bit build variant. + +@panic USER 20, if the length of the string, excluding the zero terminator, is + greater than the value of the integer template parameter for + the 8-bit build variant. +*/ + {} + + + + +template +inline TBufC::TBufC(const TDesC &aDes) + : TBufCBase16(aDes,S) +/** +Constructs a build-independent non-modifiable buffer descriptor from any +existing build independent descriptor. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +Data is copied from the source descriptor into this buffer descriptor and +the length of this buffer descriptor is set to the length of the source descriptor. + +The length of the source descriptor must not be greater than the value of +the integer template parameter, otherwise the constructor raises a USER 20 +panic for an 8 bit build variant or a USER 8 panic for a 16 bit (Unicode) +build variant. + +@param aDes The source build independent non-modifiable descriptor. + +@panic USER 8, if the length of the source descriptor is + greater than the value of the integer template parameter for + the 16-bit build variant. + +@panic USER 20, if the length of the source descriptor is + greater than the value of the integer template parameter for + the 8-bit build variant. +*/ + {} +#else +template +inline TBufC::TBufC() + : TBufCBase8() + {} +template +inline TBufC::TBufC(const TText *aString) + : TBufCBase8(aString,S) + {} +template +inline TBufC::TBufC(const TDesC &aDes) + : TBufCBase8(aDes,S) + {} +#endif +template +inline TBufC &TBufC::operator=(const TText *aString) +/** +Copies data into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aString A pointer to a zero-terminated string. + +@return A reference to this descriptor. + +@panic USER 11, if the length of the string, excluding the zero terminator, + is greater than the maximum length of this (target) descriptor + for the 16-bit build variant. + +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the maximum length of this (target) descriptor + for the 8-bit build variant. +*/ + {Copy(aString,S);return(*this);} + + + + +template +inline TBufC &TBufC::operator=(const TDesC &aDes) +/** +Copies data into this descriptor, replacing any existing data. + +The length of this descriptor is set to reflect the new data. + +@param aDes A build independent non-modifiable descriptor. + +@return A reference to this descriptor. + +@panic USER 11, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor for the 16-bit + build variant. + +@panic USER 23, if the length of the descriptor aDes is greater than the + maximum length of this (target) descriptor for the 8-bit + build variant. +*/ + {Copy(aDes,S);return(*this);} + + + + +template +inline TPtr TBufC::Des() +/** +Creates and returns a build-independent modifiable pointer descriptor for +the data represented by this build-independent non-modifiable buffer +descriptor. + +The content of a non-modifiable buffer descriptor normally cannot be altered, +other than by complete replacement of the data. Creating a modifiable pointer +descriptor provides a way of changing the data. + +The modifiable pointer descriptor is set to point to this non-modifiable buffer +descriptor's data. + +The length of the modifiable pointer descriptor is set to the length of this +non-modifiable buffer descriptor. + +The maximum length of the modifiable pointer descriptor is set to the value +of the integer template parameter. + +When data is modified through this new pointer descriptor, the lengths of +both it and this constant buffer descriptor are changed. + +@return A build independent modifiable pointer descriptor representing the + data in this build independent non-modifiable buffer descriptor. +*/ + {return(DoDes(S));} + + + + +// Template class TBuf +#if defined(_UNICODE) && !defined(__KERNEL_MODE__) +template +inline TBuf::TBuf() + : TBufBase16(S) +/** +Creates a build-independent modifiable buffer descriptor which +contains no data. + +The integer template parameter determines the size of the data area that is created +as part of the object, and defines the descriptor's maximum length. +*/ + {} + + + + +template +inline TBuf::TBuf(TInt aLength) + : TBufBase16(aLength,S) +/** +Constructs an empty build independent modifiable buffer descriptor and +sets its length to the specified value. + +No data is assigned to the descriptor. + +The integer template parameter determines the size of the data area created +as part of the object and defines the descriptor's maximum length. + +@param aLength The length of this modifiable buffer descriptor. + +@panic USER 8, if aLength is negative and is greater than the value of the + integer template parameter for a 16-bit build variant. + +@panic USER 20, if aLength is negative and is greater than the value of the + integer template parameter for a 8-bit build variant. +*/ + {} + + + + +template +inline TBuf::TBuf(const TText *aString) + : TBufBase16(aString,S) +/** +Constructs the build-independent modifiable buffer descriptor from +a zero terminated string. + +The integer template parameter determines the size of the data area which +is created as part of this object. + +The string, excluding the zero terminator, is copied into this buffer +descriptor's data area. The length of this buffer descriptor is set to +the length of the string, excluding the zero terminator. + +@param aString A pointer to a zero terminated string. + +@panic USER 11, if the length of the string, excluding the zero terminator, + is greater than the value of the integer template parameter + for a 16-bit build variant. +@panic USER 23, if the length of the string, excluding the zero terminator, + is greater than the value of the integer template parameter + for a 8-bit build variant. +*/ + {} + + + + +template +inline TBuf::TBuf(const TDesC &aDes) + : TBufBase16(aDes,S) +/** +Constructs the build-independent modifiable buffer descriptor from any +existing build-independent descriptor. + +The integer template parameter determines the size of the data area created +as part of this object, and defines the descriptor's maximum length. + +Data is copied from the source descriptor into this modifiable buffer descriptor +and the length of this modifiable buffer descriptor is set to the length of +the source descriptor. + +@param aDes The source build independent non-modifiable descriptor. + +@panic USER 11, if the length of the source descriptor is greater than the + value of the integer template parameter for a 16-bit + build variant. +@panic USER 23, if the length of the source descriptor is greater than the + value of the integer template parameter for an 8-bit + build variant. + +*/ + {} +#else +template +inline TBuf::TBuf() + : TBufBase8(S) + {} +template +inline TBuf::TBuf(TInt aLength) + : TBufBase8(aLength,S) + {} +template +inline TBuf::TBuf(const TText *aString) + : TBufBase8(aString,S) + {} +template +inline TBuf::TBuf(const TDesC &aDes) + : TBufBase8(aDes,S) + {} +#endif +template +inline TBuf &TBuf::operator=(const TText *aString) + {Copy(aString);return(*this);} +template +inline TBuf &TBuf::operator=(const TDesC &aDes) + {Copy(aDes);return(*this);} +template +inline TBuf &TBuf::operator=(const TBuf &aBuf) + {Copy(aBuf);return(*this);} + + + + +// Template class TLitC +template +inline const TDesC* TLitC::operator&() const +/** +Returns a const TDesC type pointer. + +@return A descriptor type pointer to this literal. +*/ + {return REINTERPRET_CAST(const TDesC*,this);} + + + + +template +inline const TDesC& TLitC::operator()() const +/** +Returns a const TDesC type reference. + +@return A descriptor type reference to this literal +*/ + {return *operator&();} + + + + +template +inline TLitC::operator const TDesC&() const +/** +Invoked by the compiler when a TLitC type is passed to a function +which is prototyped to take a const TDesC& type. +*/ + {return *operator&();} + + + + +template +inline TLitC::operator const __TRefDesC() const +/** +Invoked by the compiler when a TLitC type is passed to a function +which is prototyped to take a const TRefByValue type. + +@see __TRefDesC. +*/ + {return *operator&();} + + + + +// Template class TPckgC +template +inline TPckgC::TPckgC(const T &aRef) + : TPtrC8((const TUint8 *)&aRef,sizeof(T)) +/** +Constructs a packaged non-modifiable pointer descriptor to represent +the specified object whose type is defined by the template parameter. + +@param aRef The object to be represented by this packaged non-modifiable + pointer descriptor. +*/ + {} + + + + +template +inline const T &TPckgC::operator()() const +/** +Gets a reference to the object represented by this packaged non-modifiable +pointer descriptor. + +@return The packaged object +*/ + {return(*((const T *)iPtr));} + + + + +// Template class TPckg +template +inline TPckg::TPckg(const T &aRef) + : TPtr8((TUint8 *)&aRef,sizeof(T),sizeof(T)) +/** +Constructs a packaged modifiable pointer descriptor to represent the specified +object whose type is defined by the template parameter. + +@param aRef The object to be represented by this packaged modifiable pointer + descriptor. +*/ + {} + + + + +template +inline T &TPckg::operator()() +/** +Gets a reference to the object represented by this packaged +modifiable pointer descriptor. + +@return The packaged object. +*/ + {return(*((T *)iPtr));} + + + + +// Template class TPckgBuf +template +inline TPckgBuf::TPckgBuf() + : TAlignedBuf8(sizeof(T)) +/** +Constructs a packaged modifiable buffer descriptor for an object whose type +is defined by the template parameter. + +The length of the packaged descriptor is set to the length of the templated +class but no data is assigned into the descriptor. +*/ + {new(&this->iBuf[0]) T;} + + + + +template +inline TPckgBuf::TPckgBuf(const T &aRef) + : TAlignedBuf8(sizeof(T)) +/** +Constructs a packaged modifiable buffer descriptor for an object whose type +is defined by the template parameter and copies the supplied object into the +descriptor. + +The length of the packaged descriptor is set to the length of the templated +class. + +@param aRef The source object to be copied into the packaged modifiable buffer + descriptor. +*/ + {new(&this->iBuf[0]) T(aRef);} + + + + +template +inline TPckgBuf &TPckgBuf::operator=(const TPckgBuf &aRef) +/** +Copies data from the specified packaged modifiable buffer descriptor into this +packaged modifiable buffer descriptor, replacing any existing data. + +@param aRef The source packaged modifiable buffer descriptor. +@return A reference to this packaged modifiable descriptor. +*/ + {this->Copy(aRef);return(*this);} + + + + +template +inline T &TPckgBuf::operator=(const T &aRef) +/** +Copies data from the specified object into this packaged modifiable buffer +descriptor, replacing any existing data. + +@param aRef The source object. +@return A reference to the copy of the source object in the packaged modifiable + buffer descriptor. +*/ + {this->Copy((TUint8 *)&aRef,sizeof(T));return(*((T *)&this->iBuf[0]));} + + + + +template +inline T &TPckgBuf::operator()() +/** +Gets a reference to the object contained by this packaged modifiable +buffer descriptor. + +@return The packaged object. +*/ + {return(*((T *)&this->iBuf[0]));} + + + + +template +inline const T &TPckgBuf::operator()() const +/** +Gets a const reference to the object contained by this packaged modifiable +buffer descriptor. + +@return The (const) packaged object. +*/ + {return(*((T *)&this->iBuf[0]));} + + + + +// Class TRequestStatus +inline TRequestStatus::TRequestStatus() +/** +Default constructor. +*/ +: iFlags(0) + {} + + + + +inline TRequestStatus::TRequestStatus(TInt aVal) +/** +Constructs an asynchronous request status object and assigns a completion value +to it. + +@param aVal The completion value to be assigned to the constructed request + status object. +*/ + : iStatus(aVal), + iFlags(aVal==KRequestPending ? TRequestStatus::ERequestPending : 0) + + {} + + + + +inline TInt TRequestStatus::operator=(TInt aVal) +/** +Assigns the specified completion code to the request status object. + +@param aVal The value to be assigned. + +@return The value assigned. +*/ + { + if(aVal==KRequestPending) + iFlags|=TRequestStatus::ERequestPending; + else + iFlags&=~TRequestStatus::ERequestPending; + return (iStatus=aVal); + } + + + + +inline TBool TRequestStatus::operator==(TInt aVal) const +/** +Tests whether the request status object's completion code is the same as +the specified value. + +@param aVal The value to be compared. + +@return True, if the values are equal; false otherwise. +*/ + {return(iStatus==aVal);} + + + + +inline TBool TRequestStatus::operator!=(TInt aVal) const +/** +Tests whether the request status object's completion code is not equal to +the specified value. + +@param aVal The value to be compared. + +@return True, if the values are unequal; false otherwise. +*/ + {return(iStatus!=aVal);} + + + + +inline TBool TRequestStatus::operator>=(TInt aVal) const +/** +Tests whether the request status object's completion code is greater than +or equal to the specified value. + +@param aVal The value to be compared. + +@return True, if the request status object's value is greater than or equal + to the specified value; false, otherwise. +*/ + {return(iStatus>=aVal);} + + + + +inline TBool TRequestStatus::operator<=(TInt aVal) const +/** +Tests whether the request status object's completion code is less than or +equal to the specified value. + +@param aVal The value to be compared. + +@return True, if the request status object's value is less than or equal + to the specified value; false, otherwise. +*/ + {return(iStatus<=aVal);} + + + + +inline TBool TRequestStatus::operator>(TInt aVal) const +/** +Tests whether the request status object's completion code is greater than +the specified value. + +@param aVal The value to be compared. + +@return True, if the request status object's value is greater than + the specified value; false, otherwise. +*/ + {return(iStatus>aVal);} + + + + +inline TBool TRequestStatus::operator<(TInt aVal) const +/** +Tests whether the request status object's completion code is less than the +specified value. + +@param aVal The value to be compared. + +@return True, if the request status object's value is less than the specified + value; false, otherwise. +*/ + {return(iStatus>KFindHandleUniqueIdShift)&KFindHandleUniqueIdMask);} + + + + +/** +Gets the unique ID of the kernel object itself. + +@return The ID of the object. +*/ +inline TUint64 TFindHandle::ObjectID() const + {return MAKE_TUINT64(iObjectIdHigh, iObjectIdLow);} + + + + +/** +Sets the find handle to refer to a specific object. + +@oaram aIndex The current index of the object in its container. +@param aUniqueId The unique ID of the container object. +@param aObjectId The unique ID of the object iteself. +*/ +inline void TFindHandle::Set(TInt aIndex, TInt aUniqueId, TUint64 aObjectId) + { + iHandle=(TInt)((aUniqueId<=0) + { + iHandle = aHandleOrError; + return KErrNone; + } + iHandle = 0; + return aHandleOrError; + } + + + + +// Class RSemaphore +#ifndef __KERNEL_MODE__ +inline TInt RSemaphore::Open(const TFindSemaphore& aFind,TOwnerType aType) +/** +Opens a handle to the global semaphore found using a TFindSemaphore object. + +A TFindSemaphore object is used to find all global semaphores whose full names +match a specified pattern. + +By default, any thread in the process can use this instance of RSemaphore +to access the semaphore. However, specifying EOwnerThread as the second parameter +to this function, means that only the opening thread can use this instance +of RSemaphore to access the semaphore; any other thread in this process that +wants to access the semaphore must either duplicate the handle or use OpenGlobal() +again. + +@param aFind A reference to the TFindSemaphore object used to find the semaphore. +@param aType An enumeration whose enumerators define the ownership of this + semaphore handle. If not explicitly specified, EOwnerProcess is + taken as default. + +@return KErrNone if successful otherwise another of the system wide error codes. +*/ + {return(RHandleBase::Open((const TFindHandleBase&)aFind,aType));} +#endif + + + + +// Class RFastLock + + +/** +Default constructor. +*/ +inline RFastLock::RFastLock() + : iCount(0) + {} + + + + +// Class RMessagePtr2 + + +/** +Default constructor +*/ +inline RMessagePtr2::RMessagePtr2() + : iHandle(0) + {} + + + + +/** +Tests whether this message handle is empty. + +@return True, if this message handle is empty, false, otherwise. +*/ +inline TBool RMessagePtr2::IsNull() const + {return iHandle==0;} + + + + +/** +Gets the message handle value. + +@return The message handle value. +*/ +inline TInt RMessagePtr2::Handle() const + {return iHandle;} +inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight) + {return aLeft.Handle()==aRight.Handle();} +inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight) + {return aLeft.Handle()!=aRight.Handle();} + + + + + +// Class RMessage + + +/** +Default constructor +*/ +inline RMessage2::RMessage2() + {} + + + + +/** +Gets the the number of the function requested by the client. + +@return The function number. +*/ +inline TInt RMessage2::Function() const + {return(iFunction);} + + + + +/** +Gets the first message argument as an integer value. + +@return The first message argument. +*/ +inline TInt RMessage2::Int0() const + {return(iArgs[0]);} + + + + +/** +Gets the second message argument as an integer value. + +@return The second message argument. +*/ +inline TInt RMessage2::Int1() const + {return(iArgs[1]);} + + + + +/** +Gets the third message argument as an integer value. + +@return The third message argument. +*/ +inline TInt RMessage2::Int2() const + {return(iArgs[2]);} + + + +/** +Gets the fourth message argument as an integer value. + +@return The fourth message argument. +*/ +inline TInt RMessage2::Int3() const + {return(iArgs[3]);} + + + +/** +Gets the first message argument as a pointer type. + +@return The first message argument. +*/ +inline const TAny *RMessage2::Ptr0() const + {return((const TAny *)iArgs[0]);} + + + + +/** +Gets the second message argument as a pointer type. + +@return The second message argument. +*/ +inline const TAny *RMessage2::Ptr1() const + {return((const TAny *)iArgs[1]);} + + + + +/** +Gets the third message argument as a pointer type. + +@return The third message argument. +*/ +inline const TAny *RMessage2::Ptr2() const + {return((const TAny *)iArgs[2]);} + + + + +/** +Gets the fourth message argument as a pointer type. + +@return The fourth message argument. +*/ +inline const TAny *RMessage2::Ptr3() const + {return((const TAny *)iArgs[3]);} + + + +/** +Gets a pointer to the session. + +@return A pointer to the session object. +*/ +inline CSession2* RMessage2::Session() const + {return (CSession2*)iSessionPtr; } + + + + +// Class TUid +inline TUid TUid::Uid(TInt aUid) +/** +Constructs the TUid object from a 32-bit integer. + +@param aUid The 32-bit integer value from which the TUid object is to be + constructed. + +@return The constructed TUid object. +*/ + {TUid uid={aUid};return uid;} + + + + +inline TUid TUid::Null() +/** +Constructs a Null-valued TUid object. + +@return The constructed Null-valued TUid object. +*/ + {TUid uid={KNullUidValue};return uid;} + + + + +#ifndef __KERNEL_MODE__ +// Template class TArray +template +inline TArray::TArray(TInt (*aCount)(const CBase *aPtr),const TAny *(*anAt)(const CBase *aPtr,TInt anIndex),const CBase *aPtr) + : iPtr(aPtr),iCount(aCount),iAt(anAt) +/** +Constructor. + +A TArray object is not intended to be instantiated explicitly. An object of +this type is instantiated as a result of a call to to the Array() member +function of a concrete array class + +@param aCount A pointer to a function which takes a + @code + const CBase* + @endcode + argument and returns a + @code + TInt + @endcode + aCount must point to the member function which returns the + current number of elements of type class T contained in the + array at aPtr, for which this TArray is being constructed. + This argument is supplied by the Array() member function of the + array class. +@param anAt A pointer to a function which takes a + @code + const CBase* + @endcode + and a + @code + TInt + @endcode + argument, and returns a pointer to + @code + TAny + @endcode + anAt must point to the member function which returns a reference + to the element located at position anIndex within the array at + aPtr, for which this TArray is being constructed. + This argument is supplied by the Array() member function of the + array class. +@param aPtr A pointer to the array for which this TArray is being + constructed. This argument is supplied by the Array() member + function of the array class. + +@see CArrayFixFlat::Array +@see CArrayFixSeg::Array +@see CArrayVarFlat::Array +@see CArrayVarSeg::Array +@see CArrayPakFlat::Array +@see RArray::Array +@see RPointerArray::Array +@see RArray::Array +@see RArray::Array +*/ + {} + + + + +template +inline TInt TArray::Count() const +/** +Gets the number of elements currently held in the array for which this generic +array has been constructed. + +@return The number of array elements. +*/ + {return((*iCount)(iPtr));} + + + + +template +inline const T &TArray::operator[](TInt anIndex) const +/** +Gets a reference to the element located at the specified position. + +The returned reference is const and cannot be used to change the element. +Any member function of the referenced template class T must be declared +as const if that function is to be accessed through this operator. + +@param anIndex The position of the element within the array for which this + TArray has been constructed. The position is relative to zero; + i.e. zero implies the first element in the array. + +@return A const reference to the element located at position anIndex within + the array for which this TArray has been constructed. + +@panic E32USER-CBase 21, if anIndex is negative, or greater than or equal to + the number of objects currently within the array. +*/ + {return(*((const T *)(*iAt)(iPtr,anIndex)));} +#endif + + + + +// Class TIdentityRelation +template +inline TIdentityRelation::TIdentityRelation() +/** +Constructs the object to use the equality operator (==) defined for class T +to determine whether two class T type objects match. +*/ + {iIdentity=(TGeneralIdentityRelation)&EqualityOperatorCompare;} + + + + +template +inline TIdentityRelation::TIdentityRelation( TBool (*anIdentity)(const T&, const T&) ) +/** +Constructs the object taking the specified function as an argument. + +The specified function should implement an algorithm for determining whether +two class T type objects match. It should return: + +1. true, if the two objects match. + +2. false, if the two objects do not match. + +@param anIdentity A pointer to a function that takes constant references to two + class T objects and returns a TInt value. +*/ + { iIdentity=(TGeneralIdentityRelation)anIdentity; } + + + + +template +inline TIdentityRelation::operator TGeneralIdentityRelation() const +/** +Operator that gets the function that determines whether two +objects of a given class type match. +*/ + { return iIdentity; } + + + +template +inline TBool TIdentityRelation::EqualityOperatorCompare(const T& aLeft, const T& aRight) +/** +Compares two objects of class T using the equality operator defined for class T. +*/ + {return aLeft == aRight;} + + + +// Class TLinearOrder +template +inline TLinearOrder::TLinearOrder( TInt(*anOrder)(const T&, const T&) ) +/** +Constructs the object taking the specified function as an argument. + +The specified function should implement an algorithm that determines the +order of two class T type objects. It should return: + +1. zero, if the two objects are equal. + +2. a negative value, if the first object is less than the second. + +3. a positive value, if the first object is greater than the second. + +@param anOrder A pointer to a function that takes constant references to two + class T objects and returns a TInt value. +*/ + { iOrder=(TGeneralLinearOrder)anOrder; } + + + + +template +inline TLinearOrder::operator TGeneralLinearOrder() const +/** +Operator that gets the function that determines the order of two +objects of a given class type. +*/ + { return iOrder; } + + + + +// Class RPointerArray + +/** +Default C++ constructor. + +This constructs an array object for an array of pointers with default +granularity, which is 8. +*/ +template +inline RPointerArray::RPointerArray() + : RPointerArrayBase() + {} + + + + +/** +C++ constructor with granularity. + +This constructs an array object for an array of pointers with the specified +granularity. + +@param aGranularity The granularity of the array. + +@panic USER 127, if aGranularity is not positive, or greater than or equal + to 0x10000000. +*/ +template +inline RPointerArray::RPointerArray(TInt aGranularity) + : RPointerArrayBase(aGranularity) + {} + + + + +/** +C++ constructor with minimum growth step and exponential growth factor. + +This constructs an array object for an array of pointers with the specified +minimum growth step and exponential growth factor. + +@param aMinGrowBy The minimum growth step of the array. Must be between 1 and + 65535 inclusive. +@param aFactor The factor by which the array grows, multiplied by 256. + For example 512 specifies a factor of 2. Must be between 257 + and 32767 inclusive. + +@panic USER 192, if aMinGrowBy<=0 or aMinGrowBy>65535. +@panic USER 193, if aFactor<=257 or aFactor>32767. +*/ +template +inline RPointerArray::RPointerArray(TInt aMinGrowBy, TInt aFactor) + : RPointerArrayBase(aMinGrowBy, aFactor) + {} + + + + +template +inline void RPointerArray::Close() +/** +Closes the array and frees all memory allocated to it. + +The function must be called before this array object goes out of scope. + +Note that the function does not delete the objects whose pointers are contained +in the array. +*/ + {RPointerArrayBase::Close();} + + + + +template +inline TInt RPointerArray::Count() const +/** +Gets the number of object pointers in the array. + +@return The number of object pointers in the array. +*/ + { return RPointerArrayBase::Count(); } + + + + +template +inline T* const& RPointerArray::operator[](TInt anIndex) const +/** +Gets a reference to the object pointer located at the specified +position within the array. + +The compiler chooses this option if the returned reference is used in +an expression where the reference cannot be modified. + +@param anIndex The position of the object pointer within the array. The + position is relative to zero, i.e. zero implies the object + pointer at the beginning of the array. + +@return A const reference to the object pointer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {return (T* const&)At(anIndex);} + + + + +template +inline T*& RPointerArray::operator[](TInt anIndex) +/** +Gets a reference to the object pointer located at the specified +position within the array. + +The compiler chooses this option if the returned reference is used in +an expression where the reference can be modified. + +@param anIndex The position of the object pointer within the array. The + position is relative to zero, i.e. zero implies the object + pointer at the beginning of the array. + +@return A non-const reference to the object pointer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {return (T*&)At(anIndex);} + + + + +template +inline TInt RPointerArray::Append(const T* anEntry) +/** +Appends an object pointer onto the array. + +@param anEntry The object pointer to be appended. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::Append(anEntry); } + + + + +template +inline TInt RPointerArray::Insert(const T* anEntry, TInt aPos) +/** +Inserts an object pointer into the array at the specified position. + +@param anEntry The object pointer to be inserted. +@param aPos The position within the array where the object pointer is to be + inserted. The position is relative to zero, i.e. zero implies + that a pointer is inserted at the beginning of the array. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. + +@panic USER 131, if aPos is negative, or is greater than the number of object + pointers currently in the array. +*/ + { return RPointerArrayBase::Insert(anEntry,aPos); } + + + + +template +inline void RPointerArray::Remove(TInt anIndex) +/** +Removes the object pointer at the specified position from the array. + +Note that the function does not delete the object whose pointer is removed. + +@param anIndex The position within the array from where the object pointer + is to be removed. The position is relative to zero, i.e. zero + implies that a pointer at the beginning of the array is to be + removed. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {RPointerArrayBase::Remove(anIndex);} + + + + +template +inline void RPointerArray::Compress() +/** +Compresses the array down to a minimum. + +After a call to this function, the memory allocated to the array is just +sufficient for its contained object pointers. +Subsequently adding a new object pointer to the array +always results in a re-allocation of memory. +*/ + {RPointerArrayBase::Compress();} + + + + +template +inline void RPointerArray::Reset() +/** +Empties the array. + +It frees all memory allocated to the array and resets the internal state so +that it is ready to be reused. + +This array object can be allowed to go out of scope after a call to this +function. + +Note that the function does not delete the objects whose pointers are contained +in the array. +*/ + {RPointerArrayBase::Reset();} + + + + +template +inline TInt RPointerArray::Find(const T* anEntry) const +/** +Finds the first object pointer in the array which matches the specified object +pointer, using a sequential search. + +Matching is based on the comparison of pointers. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The object pointer to be found. +@return The index of the first matching object pointer within the array. + KErrNotFound, if no matching object pointer can be found. +*/ + { return RPointerArrayBase::Find(anEntry); } + + + + +template +inline TInt RPointerArray::Find(const T* anEntry, TIdentityRelation anIdentity) const +/** +Finds the first object pointer in the array whose object matches the specified +object, using a sequential search and a matching algorithm. + +The algorithm for determining whether two class T objects match is provided +by a function supplied by the caller. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The object pointer to be found. +@param anIdentity A package encapsulating the function which determines whether + two class T objects match. + +@return The index of the first matching object pointer within the array. + KErrNotFound, if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::Find(anEntry,anIdentity); } + + + + +template +inline TInt RPointerArray::FindReverse(const T* anEntry) const +/** +Finds the last object pointer in the array which matches the specified object +pointer, using a sequential search. + +Matching is based on the comparison of pointers. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The object pointer to be found. +@return The index of the last matching object pointer within the array. + KErrNotFound, if no matching object pointer can be found. +*/ + { return RPointerArrayBase::FindReverse(anEntry); } + + + + +template +inline TInt RPointerArray::FindReverse(const T* anEntry, TIdentityRelation anIdentity) const +/** +Finds the last object pointer in the array whose object matches the specified +object, using a sequential search and a matching algorithm. + +The algorithm for determining whether two class T objects match is provided +by a function supplied by the caller. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The object pointer to be found. +@param anIdentity A package encapsulating the function which determines whether + two class T objects match. + +@return The index of the last matching object pointer within the array. + KErrNotFound, if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::FindReverse(anEntry,anIdentity); } + + + + +template +inline TInt RPointerArray::FindInAddressOrder(const T* anEntry) const +/** +Finds the object pointer in the array that matches the specified object +pointer, using a binary search technique. + +The function assumes that object pointers in the array are in address order. + +@param anEntry The object pointer to be found. + +@return The index of the matching object pointer within the array or KErrNotFound + if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); } + + + + +template +inline TInt RPointerArray::FindInOrder(const T* anEntry, TLinearOrder anOrder) const +/** +Finds the object pointer in the array whose object matches the specified +object, using a binary search technique and an ordering algorithm. + +The function assumes that existing object pointers in the array are ordered +so that the objects themselves are in object order as determined by an algorithm +supplied by the caller and packaged as a TLinearOrder. + +@param anEntry The object pointer to be found. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return The index of the matching object pointer within the array or KErrNotFound, + if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::FindIsq(anEntry,anOrder); } + + + + +template +inline TInt RPointerArray::FindInAddressOrder(const T* anEntry, TInt& anIndex) const +/** +Finds the object pointer in the array that matches the specified object +pointer, using a binary search technique. + +The function assumes that object pointers in the array are in address order. + +@param anEntry The object pointer to be found. +@param anIndex A TInt supplied by the caller. On return, contains an index + value: + If the function returns KErrNone, this is the index of the + matching object pointer within the array. + If the function returns KErrNotFound, this is the + index of the first object pointer within the array which + logically follows after anEntry. + +@return KErrNone, if a matching object pointer is found. + KErrNotFound, if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); } + + + + +template +inline TInt RPointerArray::FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder anOrder) const +/** +Finds the object pointer in the array whose object matches the specified +object, using a binary search technique and an ordering algorithm. + +The function assumes that existing object pointers in the array are ordered +so that the objects themselves are in object order as determined by an +algorithm supplied by the caller and packaged as a TLinearOrder. + +@param anEntry The object pointer to be found. +@param anIndex A TInt supplied by the caller. On return, contains an + index value: + If the function returns KErrNone, this is the index of the + matching object pointer within the array. + If the function returns KErrNotFound, this is the index of + the first object pointer in the array whose object is larger + than the entry being searched for - if no objects pointed to in + the array are larger, then the index value is the same as the + total number of object pointers in the array. + +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone, if a matching object pointer is found. + KErrNotFound, if no suitable object pointer can be found. +*/ + { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder); } + + + + +template +inline TInt RPointerArray::SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const +/** +Finds the object pointer in the array that matches the specified object +pointer, using a binary search technique. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that object pointers in the array are in address order. + +@param anEntry The object pointer to be found. +@param aMode Specifies whether to find the first match, the last match or + any match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on the + value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); } + + + + +template +inline TInt RPointerArray::SpecificFindInOrder(const T* anEntry, TLinearOrder anOrder, TInt aMode) const +/** +Finds the object pointer in the array whose object matches the specified +object, using a binary search technique and an ordering algorithm. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that existing object pointers in the array are ordered +so that the objects themselves are in object order as determined by an algorithm +supplied by the caller and packaged as a TLinearOrder type. + +@param anEntry The object pointer to be found. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. +@param aMode Specifies whether to find the first match, the last match or any match, + as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on + the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::FindIsq(anEntry,anOrder,aMode); } + + + + +template +inline TInt RPointerArray::SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the object pointer in the array that matches the specified object +pointer, using a binary search technique. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that object pointers in the array are in address order. + +@param anEntry The object pointer to be found. +@param anIndex A TInt type supplied by the caller. On return, it contains an + index value depending on whether a match is found and on the + value of aMode. + If there is no matching element in the array, then this is + the index of the first element in the array that is bigger than + the element being searched for - if no elements in the array are + bigger, then the index value is the same as the total number of + elements in the array. If there is a matching element, then what + the index refers to depends on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows the + last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. + +@param aMode Specifies whether to find the first match, the last match or any + match, as defined by one of the TArrayFindMode enum values. + +@return KErrNone, if a matching object pointer is found. + KErrNotFound, if no suitable object pointer can be found. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); } + + + + +template +inline TInt RPointerArray::SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder anOrder, TInt aMode) const +/** +Finds the object pointer in the array whose object matches the specified +object, using a binary search technique and an ordering algorithm. + +Where there is more than one matching element, it finds the first, the last or any +matching element as specified by the value of aMode. + +The function assumes that existing object pointers in the array are ordered +so that the objects themselves are in object order as determined by an +algorithm supplied by the caller and packaged as a TLinearOrder type. + +@param anEntry The object pointer to be found. +@param anIndex A TInt type supplied by the caller. On return, it contains an + index value depending on whether a match is found and on the + value of aMode. If there is no matching element in the array, + then this is the index of the first element in the array + that is bigger than the element being searched for - if + no elements in the array are bigger, then the index value + is the same as the total number of elements in the array. + If there is a matching element, then what the index refers to + depends on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element + of the array, then the index value is the same as the total number of elements in the array. + +@param anOrder A package encapsulating the function which determines the order + of two class T objects. +@param aMode Specifies whether to find the first match, the last match or + any match, as defined by one of the TArrayFindMode enum values. + +@return KErrNone, if a matching object pointer is found. + KErrNotFound, if no suitable object pointer can be found. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::BinarySearch(anEntry,anIndex,anOrder,aMode); } + + + + +template +inline TInt RPointerArray::InsertInAddressOrder(const T* anEntry) +/** +Inserts an object pointer into the array in address order. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that existing object pointers within the array are in +address order. + +@param anEntry The object pointer to be inserted. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); } + + + + +template +inline TInt RPointerArray::InsertInOrder(const T* anEntry, TLinearOrder anOrder) +/** +Inserts an object pointer into the array so that the object itself is in object +order. + +The algorithm for determining the order of two class T objects is provided +by a function supplied by the caller. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that the array is ordered so that the referenced objects +are in object order. + +@param anEntry The object pointer to be inserted. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + { return RPointerArrayBase::InsertIsq(anEntry,anOrder,EFalse); } + + + + +template +inline TInt RPointerArray::InsertInAddressOrderAllowRepeats(const T* anEntry) +/** +Inserts an object pointer into the array in address order, allowing duplicates. + +If the new object pointer is a duplicate of an existing object pointer in +the array, then the new pointer is inserted after the existing one. If more +than one duplicate object pointer already exists in the array, then any new +duplicate pointer is inserted after the last one. + +The function assumes that existing object pointers within the array are in +address order. + +@param anEntry The object pointer to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); } + + + + +template +inline TInt RPointerArray::InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder anOrder) +/** +Inserts an object pointer into the array so that the object itself is in object +order, allowing duplicates + +The algorithm for determining the order of two class T objects is provided +by a function supplied by the caller. + +If the specified object is a duplicate of an existing object, then the new +pointer is inserted after the pointer to the existing object. If more than +one duplicate object already exists, then the new pointer is inserted after +the pointer to the last one. + +@param anEntry The object pointer to be inserted. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::InsertIsq(anEntry,anOrder,ETrue); } + + + + +#ifndef __KERNEL_MODE__ +template +inline RPointerArray::RPointerArray(T** aEntries, TInt aCount) + : RPointerArrayBase((TAny **)aEntries, aCount) +/** +C++ constructor with a pointer to the first array entry in a pre-existing +array, and the number of entries in that array. + +This constructor takes a pointer to a pre-existing set of entries of type +pointer to class T, which is owned by another RPointerArray object. Ownership +of the set of entries still resides with the original RPointerArray object. + +@param aEntries A pointer to the first entry of type pointer to class T in + the set of entries belonging to the existing array. +@param aCount The number of entries in the existing array. The granularity of + this array is set to this value. + +@panic USER 156, if aCount is not positive. +*/ + {} + + + + +template +inline void RPointerArray::GranularCompress() +/** +Compresses the array down to a granular boundary. + +After a call to this function, the memory allocated to the array is sufficient +for its contained object pointers. Adding new object pointers to the array +does not result in a re-allocation of memory until the the total number of +pointers reaches a multiple of the granularity. +*/ + {RPointerArrayBase::GranularCompress();} + + + + +template +inline TInt RPointerArray::Reserve(TInt aCount) +/** +Reserves space for the specified number of elements. + +After a call to this function, the memory allocated to the array is sufficient +to hold the number of object pointers specified. Adding new object pointers to the array +does not result in a re-allocation of memory until the the total number of +pointers exceeds the specified count. + +@param aCount The number of object pointers for which space should be reserved +@return KErrNone If the operation completed successfully +@return KErrNoMemory If the requested amount of memory could not be allocated +*/ + { return RPointerArrayBase::DoReserve(aCount); } + + + + +template +inline void RPointerArray::SortIntoAddressOrder() +/** +Sorts the object pointers within the array into address order. +*/ + { HeapSortUnsigned(); } + + + + +template +inline void RPointerArray::Sort(TLinearOrder anOrder) +/** +Sorts the object pointers within the array. + +The sort order of the pointers is based on the order of the referenced objects. +The referenced object order is determined by an algorithm supplied by the +caller and packaged as a TLinerOrder. + +@param anOrder A package encapsulating the function which determines the order + of two class T objects. +*/ + { HeapSort(anOrder); } + + + + +template +inline TArray RPointerArray::Array() const +/** +Constructs and returns a generic array. + +@return A generic array representing this array. + +@see TArray +*/ + { return TArray(GetCount,GetElementPtr,(const CBase*)this); } +#endif + + + +template +void RPointerArray::ResetAndDestroy() +/** +Empties the array and deletes the referenced objects. + +It frees all memory allocated to the array and resets the internal state so +that it is ready to be reused. The function also deletes all of the objects +whose pointers are contained by the array. + +This array object can be allowed to go out of scope after a call to this function. +*/ + { + TInt c=Count(); + T** pE=(T**)Entries(); + ZeroCount(); + TInt i; + for (i=0; i + +/** +Default C++ constructor. + +This constructs an array object for an array of TAny pointers with default +granularity, which is 8. +*/ +inline RPointerArray::RPointerArray() + : RPointerArrayBase() + {} + + + + +/** +C++ constructor with granularity. + +This constructs an array object for an array of TAny pointers with the specified +granularity. + +@param aGranularity The granularity of the array. + +@panic USER 127, if aGranularity is not positive, or greater than or equal + to 0x10000000. +*/ +inline RPointerArray::RPointerArray(TInt aGranularity) + : RPointerArrayBase(aGranularity) + {} + + + + +/** +C++ constructor with minimum growth step and exponential growth factor. + +This constructs an array object for an array of TAny pointers with the specified +minimum growth step and exponential growth factor. + +@param aMinGrowBy The minimum growth step of the array. Must be between 1 and + 65535 inclusive. +@param aFactor The factor by which the array grows, multiplied by 256. + For example 512 specifies a factor of 2. Must be between 257 + and 32767 inclusive. + +@panic USER 192, if aMinGrowBy<=0 or aMinGrowBy>65535. +@panic USER 193, if aFactor<=257 or aFactor>32767. +*/ +inline RPointerArray::RPointerArray(TInt aMinGrowBy, TInt aFactor) + : RPointerArrayBase(aMinGrowBy, aFactor) + {} + + + + +inline void RPointerArray::Close() +/** +Closes the array and frees all memory allocated to it. + +The function must be called before this array object goes out of scope. + +Note that the function does not delete the objects whose pointers are contained +in the array. +*/ + {RPointerArrayBase::Close();} + + + + +inline TInt RPointerArray::Count() const +/** +Gets the number of pointers in the array. + +@return The number of pointers in the array. +*/ + { return RPointerArrayBase::Count(); } + + + + +inline TAny* const& RPointerArray::operator[](TInt anIndex) const +/** +Gets a reference to the pointer located at the specified +position within the array. + +The compiler chooses this option if the returned reference is used in +an expression where the reference cannot be modified. + +@param anIndex The position of the pointer within the array. The + position is relative to zero, i.e. zero implies the object + pointer at the beginning of the array. + +@return A const reference to the pointer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {return At(anIndex);} + + + + +inline TAny*& RPointerArray::operator[](TInt anIndex) +/** +Gets a reference to the pointer located at the specified +position within the array. + +The compiler chooses this option if the returned reference is used in +an expression where the reference can be modified. + +@param anIndex The position of the pointer within the array. The + position is relative to zero, i.e. zero implies the object + pointer at the beginning of the array. + +@return A non-const reference to the pointer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {return At(anIndex);} + + + + +inline TInt RPointerArray::Append(const TAny* anEntry) +/** +Appends an pointer onto the array. + +@param anEntry The pointer to be appended. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::Append(anEntry); } + + + + +inline TInt RPointerArray::Insert(const TAny* anEntry, TInt aPos) +/** +Inserts an pointer into the array at the specified position. + +@param anEntry The pointer to be inserted. +@param aPos The position within the array where the pointer is to be + inserted. The position is relative to zero, i.e. zero implies + that a pointer is inserted at the beginning of the array. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. + +@panic USER 131, if aPos is negative, or is greater than the number of object + pointers currently in the array. +*/ + { return RPointerArrayBase::Insert(anEntry,aPos); } + + + + +inline void RPointerArray::Remove(TInt anIndex) +/** +Removes the pointer at the specified position from the array. + +Note that the function does not delete the object whose pointer is removed. + +@param anIndex The position within the array from where the pointer + is to be removed. The position is relative to zero, i.e. zero + implies that a pointer at the beginning of the array is to be + removed. + +@panic USER 130, if anIndex is negative, or is greater than the number of + objects currently in the array. +*/ + {RPointerArrayBase::Remove(anIndex);} + + + + +inline void RPointerArray::Compress() +/** +Compresses the array down to a minimum. + +After a call to this function, the memory allocated to the array is just +sufficient for its contained pointers. +Subsequently adding a new pointer to the array +always results in a re-allocation of memory. +*/ + {RPointerArrayBase::Compress();} + + + + +inline void RPointerArray::Reset() +/** +Empties the array. + +It frees all memory allocated to the array and resets the internal state so +that it is ready to be reused. + +This array object can be allowed to go out of scope after a call to this +function. + +Note that the function does not delete the objects whose pointers are contained +in the array. +*/ + {RPointerArrayBase::Reset();} + + + + +inline TInt RPointerArray::Find(const TAny* anEntry) const +/** +Finds the first pointer in the array which matches the specified pointer, using +a sequential search. + +Matching is based on the comparison of pointers. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The pointer to be found. +@return The index of the first matching pointer within the array. + KErrNotFound, if no matching pointer can be found. +*/ + { return RPointerArrayBase::Find(anEntry); } + + + + +inline TInt RPointerArray::FindReverse(const TAny* anEntry) const +/** +Finds the last pointer in the array which matches the specified pointer, using +a sequential search. + +Matching is based on the comparison of pointers. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry The pointer to be found. +@return The index of the last matching pointer within the array. + KErrNotFound, if no matching pointer can be found. +*/ + { return RPointerArrayBase::FindReverse(anEntry); } + + + + +inline TInt RPointerArray::FindInAddressOrder(const TAny* anEntry) const +/** +Finds the pointer in the array that matches the specified object +pointer, using a binary search technique. + +The function assumes that pointers in the array are in address order. + +@param anEntry The pointer to be found. + +@return The index of the matching pointer within the array or KErrNotFound + if no suitable pointer can be found. +*/ + { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry); } + + + + +inline TInt RPointerArray::FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const +/** +Finds the pointer in the array that matches the specified object +pointer, using a binary search technique. + +The function assumes that pointers in the array are in address order. + +@param anEntry The pointer to be found. +@param anIndex A TInt supplied by the caller. On return, contains an index + value: + If the function returns KErrNone, this is the index of the + matching pointer within the array. + If the function returns KErrNotFound, this is the index of the + last pointer within the array which logically + precedes anEntry. + +@return KErrNone, if a matching pointer is found. + KErrNotFound, if no suitable pointer can be found. +*/ + { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex); } + + + + +inline TInt RPointerArray::SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const +/** +Finds the pointer in the array that matches the specified pointer, using a +binary search technique. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that pointers in the array are in address order. + +@param anEntry The pointer to be found. +@param aMode Specifies whether to find the first match, the last match or + any match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on the + value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::FindIsqUnsigned((TUint)anEntry, aMode); } + + + + +inline TInt RPointerArray::SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the pointer in the array that matches the specified pointer, using a +binary search technique. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that pointers in the array are in address order. + +@param anEntry The pointer to be found. +@param anIndex A TInt type supplied by the caller. On return, it contains an + index value depending on whether a match is found and on the + value of aMode. + If there is no matching element in the array, then this is + the index of the first element in the array that is bigger than + the element being searched for - if no elements in the array are + bigger, then the index value is the same as the total number of + elements in the array. If there is a matching element, then what + the index refers to depends on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows the + last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. + +@param aMode Specifies whether to find the first match, the last match or any + match, as defined by one of the TArrayFindMode enum values. + +@return KErrNone, if a matching pointer is found. + KErrNotFound, if no suitable pointer can be found. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::BinarySearchUnsigned((TUint)anEntry,anIndex,aMode); } + + + + +inline TInt RPointerArray::InsertInAddressOrder(const TAny* anEntry) +/** +Inserts an pointer into the array in address order. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that existing pointers within the array are in +address order. + +@param anEntry The pointer to be inserted. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,EFalse); } + + + + +inline TInt RPointerArray::InsertInAddressOrderAllowRepeats(const TAny* anEntry) +/** +Inserts an pointer into the array in address order, allowing duplicates. + +If the new pointer is a duplicate of an existing pointer in +the array, then the new pointer is inserted after the existing one. If more +than one duplicate pointer already exists in the array, then any new +duplicate pointer is inserted after the last one. + +The function assumes that existing pointers within the array are in +address order. + +@param anEntry The pointer to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned((TUint)anEntry,ETrue); } + + + + +#ifndef __KERNEL_MODE__ +inline RPointerArray::RPointerArray(TAny** aEntries, TInt aCount) + : RPointerArrayBase((TAny **)aEntries, aCount) +/** +C++ constructor with a pointer to the first array entry in a pre-existing +array, and the number of entries in that array. + +This constructor takes a pointer to a pre-existing set of entries of type TAny*, +which is owned by another RPointerArray object. Ownership of the set of entries +still resides with the original RPointerArray object. + +@param aEntries A pointer to the first entry of type TAny* in the set of entries + belonging to the existing array. +@param aCount The number of entries in the existing array. The granularity of + this array is set to this value. + +@panic USER 156, if aCount is not positive. +*/ + {} + + + + +inline void RPointerArray::GranularCompress() +/** +Compresses the array down to a granular boundary. + +After a call to this function, the memory allocated to the array is sufficient +for its contained pointers. Adding new pointers to the array +does not result in a re-allocation of memory until the the total number of +pointers reaches a multiple of the granularity. +*/ + {RPointerArrayBase::GranularCompress();} + + + + +inline void RPointerArray::SortIntoAddressOrder() +/** +Sorts the pointers within the array into address order. +*/ + { HeapSortUnsigned(); } + + + + +inline TArray RPointerArray::Array() const +/** +Constructs and returns a generic array. + +@return A generic array representing this array. + +@see TArray +*/ + { return TArray(GetCount,GetElementPtr,(const CBase*)this); } +#endif + + + +template +inline RArray::RArray() + : RArrayBase(sizeof(T)) +/** +Default C++ constructor. + +This constructs an array object for an array of type class T objects with +default granularity and key offset value. The default granularity is 8 and +the defaul key offset value is zero. + +@panic USER 129, if the size of class T is not positive or is not less + than 640. +*/ + {} + + + + +template +inline RArray::RArray(TInt aGranularity) + : RArrayBase(sizeof(T),aGranularity) +/** +C++ constructor with granularity. + +This constructs an array object for an array of type class T objects with +a specified granularity and default key offset value. The default key offset +value is zero. + +@param aGranularity The granularity of the array. + +@panic USER 129, if the size of class T is not positive or is not less + than 640. +@panic USER 127, if aGranularity is not positive or the product of this + value and the size of class T is not less than 0x10000000. +*/ + {} + + + + +template +inline RArray::RArray(TInt aGranularity, TInt aKeyOffset) + : RArrayBase(sizeof(T),aGranularity,aKeyOffset) +/** +C++ constructor with granularity and key offset. + +This constructs an array object for an array of type class T objects with +a specified granularity and a specified key offset value. + +@param aGranularity The granularity of the array. +@param aKeyOffset The key offset. + +@panic USER 129, if the size of class T is not positive or is not less + than 640. +@panic USER 127, if aGranularity is not positive or the product of this + value and the size of class T is not less than 0x10000000. +@panic USER 128, if aKeyOffset is not positive, or is not less than the + size of class T, or is not a multiple of 4. +*/ + {} + + + + +/** +C++ constructor with minimum growth step and exponential growth factor. + +This constructs an array object for an array of class T objects with the +specified minimum growth step and exponential growth factor. + +@param aMinGrowBy The minimum growth step of the array. Must be between 1 and + 65535 inclusive. +@param aKeyOffset The key offset. +@param aFactor The factor by which the array grows, multiplied by 256. + For example 512 specifies a factor of 2. Must be between 257 + and 32767 inclusive. + +@panic USER 129, if the size of class T is not positive or is not less than 640. +@panic USER 128, if aKeyOffset is negative, or is not less than the + size of class T, or is not a multiple of 4. +@panic USER 192, if aMinGrowBy<=0 or aMinGrowBy>65535. +@panic USER 193, if aFactor<=257 or aFactor>32767. +*/ +template +inline RArray::RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor) + : RArrayBase(sizeof(T), aMinGrowBy, aKeyOffset, aFactor) + {} + + + + +template +inline RArray::RArray(TInt aEntrySize,T* aEntries, TInt aCount) + : RArrayBase(aEntrySize,aEntries,aCount) +/** +C++ constructor with size of entry, a pointer to the first array entry in a +pre-existing array, and the number of entries in that array. + +This constructor takes a pointer to a pre-existing set of entries of type +class T objects owned by another RArray object. Ownership of the set of entries +still resides with the original RArray object. + +This array is assigned a default granularity and key offset value. The default +granularity is 8 and the default key offset value is zero. + +The purpose of constructing an array in this way is to allow sorting and +finding operations to be done without further allocation of memory. + +@param aEntrySize The size of an entry in the existing array. +@param aEntries A pointer to the first entry of type class T in the set of + entries belonging to the existing array. +@param aCount The number of entries in the existing array. + +@panic USER 129, if aEntrySize is not positive or is not less than 640. +@panic USER 156, if aCount is not positive. +*/ + {} + + + + +template +inline void RArray::Close() +/** +Closes the array and frees all memory allocated to the array. + +The function must be called before this array object is destroyed. +*/ + {RArrayBase::Close();} + + + + +template +inline TInt RArray::Count() const +/** +Gets the number of objects in the array. + +@return The number of objects in the array. +*/ + {return RArrayBase::Count();} + + + + +template +inline const T& RArray::operator[](TInt anIndex) const +/** +Gets a reference to an object located at a specified position within the array. + +The compiler chooses this function if the returned reference is used in an +expression where the reference cannot be modified. + +@param anIndex The position of the object within the array. The position is + relative to zero, i.e. zero implies the object at the beginning + of the array. + +@return A const reference to the object at position anIndex within the array. + +@panic USER 130, if anIndex is negative or is greater than the number of + objects currently in the array +*/ + {return *(const T*)At(anIndex); } + + + + +template +inline T& RArray::operator[](TInt anIndex) +/** +Gets a reference to an object located at a specified position within the array. + +The compiler chooses this function if the returned reference is used in an +expression where the reference can be modified. + +@param anIndex The position of the object within the array. The position is + relative to zero, i.e. zero implies the object at the beginning + of the array. + +@return A non-const reference to the object at position anIndex within the array. + +@panic USER 130, if anIndex is negative or is greater than the number of + objects currently in the array +*/ + {return *(T*)At(anIndex); } + + + + +template +inline TInt RArray::Append(const T& anEntry) +/** +Apends an object onto the array. + +@param anEntry A reference to the object of type class T to be appended. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + {return RArrayBase::Append(&anEntry);} + + + + +template +inline TInt RArray::Insert(const T& anEntry, TInt aPos) +/** +Inserts an object into the array at a specified position. + +@param anEntry The class T object to be inserted. +@param aPos The position within the array where the object is to + be inserted. The position is relative to zero, i.e. zero + implies that an object is inserted at the beginning of + the array. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. + +@panic USER 131, if aPos is negative or is greater than the number of objects + currently in the array. +*/ + {return RArrayBase::Insert(&anEntry,aPos);} + + + + +template +inline void RArray::Remove(TInt anIndex) +/** +Removes the object at a specified position from the array. + +@param anIndex The position within the array from where the object is to be + removed. The position is relative to zero, i.e. zero implies + that an object at the beginning of the array is to be removed. + +@panic USER 130, if anIndex is negative or is greater than the number of + objects currently in the array. +*/ + {RArrayBase::Remove(anIndex);} + + + + +template +inline void RArray::Compress() +/** +Compresses the array down to a minimum. + +After a call to this function, the memory allocated to the array is just +sufficient for its contained objects. Subsequently adding a new object to the +array always results in a re-allocation of memory. +*/ + {RArrayBase::Compress();} + + + + +template +inline void RArray::Reset() +/** +Empties the array, so that it is ready to be reused. + +The function frees all memory allocated to the array and resets the internal +state so that it is ready to be reused. + +This array object can be allowed to go out of scope after a call to this function. +*/ + {RArrayBase::Reset();} + + + + +template +inline TInt RArray::Find(const T& anEntry) const +/** +Finds the first object in the array which matches the specified object using +a sequential search. + +Matching is based on the comparison of a TInt value at the key offset position +within the objects. + +For classes which define their own equality operator (==), the alternative method +Find(const T& anEntry, TIdentityRelation anIdentity) is recommended. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry A reference to an object of type class T to be used for matching. + +@return The index of the first matching object within the array. + KErrNotFound, if no matching object can be found. +*/ + {return RArrayBase::Find(&anEntry);} + + + + +template +inline TInt RArray::Find(const T& anEntry, TIdentityRelation anIdentity) const +/** +Finds the first object in the array which matches the specified object using +a sequential search and a matching algorithm. + +The algorithm for determining whether two class T type objects match is provided +by a function supplied by the caller. + +Such a function need not be supplied if an equality operator (==) is defined for class T. +In this case, default construction of anIdentity provides matching, as in the example below: + +@code +//Construct a TPoint and append to an RArray +TPoint p1(0,0); +RArray points; +points.AppendL(p1); +//Find position of p1 in points using TIdentityRelation default construction +TInt r = points.Find(p1, TIdentityRelation()); +@endcode + +The find operation always starts at the low index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry A reference to an object of type class T to be used + for matching. +@param anIdentity A package encapsulating the function which determines whether + two class T type objects match. + +@return The index of the first matching object within the array. + KErrNotFound, if no matching object can be found. +*/ + {return RArrayBase::Find(&anEntry,anIdentity);} + + + + +template +inline TInt RArray::FindReverse(const T& anEntry) const +/** +Finds the last object in the array which matches the specified object using +a sequential search. + +Matching is based on the comparison of a TInt value at the key offset position +within the objects. + +For classes which define their own equality operator (==), the alternative method +FindReverse(const T& anEntry, TIdentityRelation anIdentity) is recommended. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry A reference to an object of type class T to be used for matching. + +@return The index of the last matching object within the array. + KErrNotFound, if no matching object can be found. +*/ + {return RArrayBase::FindReverse(&anEntry);} + + + + +template +inline TInt RArray::FindReverse(const T& anEntry, TIdentityRelation anIdentity) const +/** +Finds the last object in the array which matches the specified object using +a sequential search and a matching algorithm. + +The algorithm for determining whether two class T type objects match is provided +by a function supplied by the caller. + +Such a function need not be supplied if an equality operator (==) is defined for class T. +In this case, default construction of anIdentity provides matching. + +See Find(const T& anEntry, TIdentityRelation anIdentity) for more details. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of objects in the array. + +@param anEntry A reference to an object of type class T to be used + for matching. +@param anIdentity A package encapsulating the function which determines whether + two class T type objects match. + +@return The index of the last matching object within the array. + KErrNotFound, if no matching object can be found. +*/ + {return RArrayBase::FindReverse(&anEntry,anIdentity);} + + + + +template +inline TInt RArray::FindInSignedKeyOrder(const T& anEntry) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The function assumes that existing objects within the array are in signed +key order. + +@param anEntry A reference to an object of type class T to be used for matching. + +@return The index of the matching object within the array, or KErrNotFound + if no matching object can be found. +*/ + {return RArrayBase::FindIsqSigned(&anEntry);} + + + + +template +inline TInt RArray::FindInUnsignedKeyOrder(const T& anEntry) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The function assumes that existing objects within the array are in unsigned +key order. + +@param anEntry A reference to an object of type class T to be used for matching. + +@return The index of the matching object within the array, or KErrNotFound + if no matching object can be found. +*/ + {return RArrayBase::FindIsqUnsigned(&anEntry);} + + + + +template +inline TInt RArray::FindInOrder(const T& anEntry, TLinearOrder anOrder) const +/** +Finds the object in the array which matches the specified object using a binary +search technique and an ordering algorithm. + +The function assumes that existing objects within the array are in object +order as determined by an algorithm supplied by the caller and packaged as +a TLinearOrder. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return The index of the matching object within the array, or KErrNotFound if + no matching object can be found. +*/ + {return RArrayBase::FindIsq(&anEntry,anOrder);} + + + + +template +inline TInt RArray::FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The function assumes that existing objects within the array are in signed +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex On return contains an index value. If the function returns KErrNone, + this is the index of the matching object within the array. + If the function returns KErrNotFound, this is the index of the + first element in the array whose key is bigger than the key of the + element being sought. If there are no elements in the array with + a bigger key, then the index value is the same as the total + number of elements in the array. +@return KErrNone if a matching object is found, or KErrNotFound if no matching + object can be found. +*/ + {return RArrayBase::BinarySearchSigned(&anEntry,anIndex);} + + + + +template +inline TInt RArray::FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The function assumes that existing objects within the array are in unsigned +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex On return contains an index value. If the function returns + KErrNone, this is the index of the matching object within the + array. + If the function returns KErrNotFound, this is the index of the + first element in the array whose key is bigger than the key of the + element being sought. If there are no elements in the array with + a bigger key, then the index value is the same as the total + number of elements in the array. +@return KErrNone if a matching object is found, or KErrNotFound if no matching + object can be found. +*/ + {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex);} + + + + +template +inline TInt RArray::FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder anOrder) const +/** +Finds the object in the array which matches the specified object using a binary +search technique and an ordering algorithm. + +The function assumes that existing objects within the array are in object +order as determined by an algorithm supplied by the caller and packaged as +a TLinearOrder. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex On return contains an index value. If the function returns + KErrNone, this is the index of the matching object within the + array. + If the function returns KErrNotFound, this is the index of the + first element in the array that is bigger than the element being + searched for - if no elements in the array are bigger, then + the index value is the same as the total number of elements in + the array. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone if a matching object is found. KErrNotFound if no matching + object can be found. +*/ + {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder);} + + + + +template +inline TInt RArray::SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The element ordering is determined by a signed 32-bit word +(the key) embedded in each array element. In the case that there is more than +one matching element, finds the first, last or any match as specified by +the value of aMode. + +The function assumes that existing objects within the array are in signed +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param aMode Specifies whether to find the first match, the last match or + any match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on the + value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + {return RArrayBase::FindIsqSigned(&anEntry,aMode);} + + + + +template +inline TInt RArray::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The element ordering is determined by an unsigned 32-bit word +(the key) embedded in each array element. Where there is more than +one matching element, it finds the first, last or any matching element +as specified by the value of aMode. + +The function assumes that existing objects within the array are in unsigned +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param aMode Specifies whether to find the first match, the last match or + any match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on the + value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows the + last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + {return RArrayBase::FindIsqUnsigned(&anEntry,aMode);} + + + + +template +inline TInt RArray::SpecificFindInOrder(const T& anEntry, TLinearOrder anOrder, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique and an ordering algorithm. + +Where there is more than one matching element, it finds the first, the last +or any matching element as specified by the value of aMode. + +The function assumes that existing objects within the array are in object +order as determined by an algorithm supplied by the caller and packaged as +a TLinearOrder type. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. +@param aMode Specifies whether to find the first match, the last match or any + match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array index + of a matching element - what the index refers to depends on the value of + aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. +*/ + {return RArrayBase::FindIsq(&anEntry,anOrder,aMode);} + + + + +template +inline TInt RArray::SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The element ordering is determined by a signed 32-bit word +(the key) embedded in each array element. Where there is more than +one matching element, finds the first, last or any matching element as +specified specified by the value of aMode. + +The function assumes that existing objects within the array are in signed +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex A TInt type supplied by the caller. On return, it contains + an index value depending on whether a match is found and on the + value of aMode. If there is no matching element in the array, + then this is the index of the first element in the array that + is bigger than the element being searched for - if no elements + in the array are bigger, then the index value is the same as the + total number of elements in the array. If there is a matching + element, then what the index refers to depends on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. +@param aMode Specifies whether to find the first match, the last match or any match, + as defined by one of the TArrayFindMode enum values. + +@return KErrNone, if a matching object pointer is found; + KErrNotFound, if no suitable object pointer can be found. +*/ + {return RArrayBase::BinarySearchSigned(&anEntry,anIndex,aMode);} + + + + +template +inline TInt RArray::SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique. + +The element ordering is determined by an unsigned 32-bit word +(the key) embedded in each array element. Where there is more than +one matching element, it finds the first, last or any matching element as +specified by the value of aMode. + +The function assumes that existing objects within the array are in unsigned +key order. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex A TInt type supplied by the caller. On return, it contains an index + value depending on whether a match is found and on the value of aMode. + If there is no matching element in the array, then this is the index + of the first element in the array that is bigger than the element + being searched for - if no elements in the array are bigger, then + the index value is the same as the total number of elements in the array. + If there is a matching element, then what the index refers to depends on + the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows the + last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. +@param aMode Specifies whether to find the first match, the last match or any match, as defined by one + of the TArrayFindMode enum values. +@return KErrNone, if a matching object pointer is found; KErrNotFound, if no suitable object pointer can be found. + +@see TArrayFindMode +*/ + {return RArrayBase::BinarySearchUnsigned(&anEntry,anIndex,aMode);} + + + + +template +inline TInt RArray::SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder anOrder, TInt aMode) const +/** +Finds the object in the array which matches the specified object using a binary +search technique and a specified ordering algorithm. + +Where there is more than one matching element, it finds the first, the last or +any matching element as specified by the value of aMode. + +The function assumes that existing objects within the array are in object +order as determined by an algorithm supplied by the caller and packaged as +a TLinearOrder type. + +@param anEntry A reference to an object of type class T to be used for matching. +@param anIndex A TInt type supplied by the caller. On return, it contains + an index value depending on whether a match is found and on the + value of aMode. If there is no matching element in the array, + then this is the index of the first element in the array that + is bigger than the element being searched for - if no elements + in the array are bigger, then the index value is the same as + the total number of elements in the array. + If there is a matching element, then what the index refers to + depends on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also + the last element of the array, then the index value is the same as + the total number of elements in the array. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. +@param aMode Specifies whether to find the first match, the last match or any match, + as defined by one of the TArrayFindMode enum values. +@return KErrNone, if a matching object pointer is found; + KErrNotFound, if no suitable object pointer can be found. + +*/ + {return RArrayBase::BinarySearch(&anEntry,anIndex,anOrder,aMode);} + + + + +template +inline TInt RArray::InsertInSignedKeyOrder(const T& anEntry) +/** +Inserts an object into the array in ascending signed key order. + +The order of two class T type objects is based on comparing a TInt value +located at the key offset position within the class T object. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +@param anEntry A reference to the object of type class T to be inserted. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + {return RArrayBase::InsertIsqSigned(&anEntry,EFalse);} + + + + +template +inline TInt RArray::InsertInUnsignedKeyOrder(const T& anEntry) +/** +Inserts an object into the array in ascending unsigned key order. + +The order of two class T type objects is based on comparing a TUint value +located at the key offset position within the class T object. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +@param anEntry A reference to the object of type class T to be inserted. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + {return RArrayBase::InsertIsqUnsigned(&anEntry,EFalse);} + + + + +template +inline TInt RArray::InsertInOrder(const T& anEntry, TLinearOrder anOrder) +/** +Inserts an object of into the array in object order. + +The algorithm for determining the order of two class T type objects is provided +by a function supplied by the caller. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that existing objects within the array are in object +order. + +@param anEntry A reference to the object of type class T to be inserted. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + {return RArrayBase::InsertIsq(&anEntry,anOrder,EFalse);} + + + + +template +inline TInt RArray::InsertInSignedKeyOrderAllowRepeats(const T& anEntry) +/** +Inserts an object into the array in ascending signed key order, +allowing duplicates. + +The order of two class T type objects is based on comparing a TInt value +located at the key offset position within the class T object. + +If anEntry is a duplicate of an existing object in the array, then the new +object is inserted after the existing object. If more than one duplicate object +already exists in the array, then any new duplicate object is inserted after +the last one. + +@param anEntry A reference to the object of type class T to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + {return RArrayBase::InsertIsqSigned(&anEntry,ETrue);} + + + + +template +inline TInt RArray::InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry) +/** +Inserts an object into the array in ascending unsigned key order, allowing +duplicates. + +The order of two class T type objects is based on comparing a TUint value +located at the key offset position within the class T object. + +If anEntry is a duplicate of an existing object in the array, then the new +object is inserted after the existing object. If more than one duplicate object +already exists in the array, then any new duplicate object is inserted after +the last one. + +@param anEntry A reference to the object of type class T to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + {return RArrayBase::InsertIsqUnsigned(&anEntry,ETrue);} + + + + +template +inline TInt RArray::InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder anOrder) +/** +Inserts an object into the array in object order, allowing duplicates. + +The algorithm for determining the order of two class T type objects is provided +by a function supplied by the caller. + +If anEntry is a duplicate of an existing object in the array, then the new +object is inserted after the existing object. If more than one duplicate object +already exists in the array, then anEntry is inserted after the last one. + +The function assumes that existing objects within the array are in object +order. + +@param anEntry A reference to the object of type class T to be inserted. +@param anOrder A package encapsulating the function which determines the order + of two class T objects. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + {return RArrayBase::InsertIsq(&anEntry,anOrder,ETrue);} + + + +#ifndef __KERNEL_MODE__ + +template +inline void RArray::GranularCompress() +/** +Compresses the array down to a granular boundary. + +After a call to this function, the memory allocated to the array is sufficient +for its contained objects. Adding new objects to the array does not result +in a re-allocation of memory until the the total number of objects reaches +a multiple of the granularity. +*/ + {RArrayBase::GranularCompress();} + + + + +template +inline TInt RArray::Reserve(TInt aCount) +/** +Reserves space for the specified number of elements. + +After a call to this function, the memory allocated to the array is sufficient +to hold the number of objects specified. Adding new objects to the array +does not result in a re-allocation of memory until the the total number of +objects exceeds the specified count. + +@param aCount The number of objects for which space should be reserved +@return KErrNone If the operation completed successfully +@return KErrNoMemory If the requested amount of memory could not be allocated +*/ + { return RArrayBase::DoReserve(aCount); } + + + + +template +inline void RArray::SortSigned() +/** +Sorts the objects within the array; the sort order is assumed to be in signed +integer order. +*/ + {HeapSortSigned();} + + + + +template +inline void RArray::SortUnsigned() +/** +Sorts the objects within the array; the sort order is assumed to be in unsigned +integer order. +*/ + {HeapSortUnsigned();} + + + + +template +inline void RArray::Sort(TLinearOrder anOrder) +/** +Sorts the objects within the array using the specified TLinearOrder. + +The sort order is determined by an algorithm supplied by the caller and +packaged as a TLinerOrder. + +@param anOrder A package encapsulating the function which determines the order + of two class T type objects. +*/ + {HeapSort(anOrder);} + + + + +template +inline TArray RArray::Array() const +/** +Constructs and returns a generic array. + +@return A generic array representing this array. +*/ + { return TArray(GetCount,GetElementPtr,(const CBase*)this); } +#endif + + + + +inline RArray::RArray() + : RPointerArrayBase() +/** +Constructs an array object for an array of signed integers with +default granularity. + +The default granularity is 8. +*/ + {} + + + + +inline RArray::RArray(TInt aGranularity) + : RPointerArrayBase(aGranularity) +/** +Constructs an array object for an array of signed integers with the specified +granularity. + +@param aGranularity The granularity of the array. + +@panic USER 127, if aGranularity is not positive or is greater than or + equal to 0x10000000. +*/ + {} + + + + +/** +C++ constructor with minimum growth step and exponential growth factor. + +This constructs an array object for an array of signed integers with the +specified minimum growth step and exponential growth factor. + +@param aMinGrowBy The minimum growth step of the array. Must be between 1 and + 65535 inclusive. +@param aFactor The factor by which the array grows, multiplied by 256. + For example 512 specifies a factor of 2. Must be between 257 + and 32767 inclusive. + +@panic USER 192, if aMinGrowBy<=0 or aMinGrowBy>65535. +@panic USER 193, if aFactor<=257 or aFactor>32767. +*/ +inline RArray::RArray(TInt aMinGrowBy, TInt aFactor) + : RPointerArrayBase(aMinGrowBy, aFactor) + {} + + + + +inline void RArray::Close() +/** +Closes the array and frees all memory allocated to the array. + +The function must be called before this array object goes out of scope. +*/ + {RPointerArrayBase::Close();} + + + + +inline TInt RArray::Count() const +/** +Gets the number of signed integers in the array. + +@return The number of signed integers in the array. +*/ + { return RPointerArrayBase::Count(); } + + + + +inline const TInt& RArray::operator[](TInt anIndex) const +/** +Gets a reference to the signed integer located at a specified position within +the array. + +The compiler chooses this function if the returned reference is used in an +expression where the reference cannot be modified. + +@param anIndex The position of the signed integer within the array. The + position is relative to zero, i.e. zero implies the entry + at the beginning of the array. + +@return A const reference to the signed integer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + entries currently in the array. +*/ + {return (const TInt&)At(anIndex);} + + + + +inline TInt& RArray::operator[](TInt anIndex) +/** +Gets a reference to the signed integer located at a specified position within +the array. + +The compiler chooses this function if the returned reference is used in an +expression where the reference can be modified. + +@param anIndex The position of the signed integer within the array. The + position is relative to zero, i.e. zero implies the entry + at the beginning of the array. + +@return A non-const reference to the signed integer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + entries currently in the array. +*/ + {return (TInt&)At(anIndex);} + + + + +inline TInt RArray::Append(TInt anEntry) +/** +Appends a signed integer onto the array. + +@param anEntry The signed integer to be appended. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::Append((const TAny*)anEntry); } + + + + +inline TInt RArray::Insert(TInt anEntry, TInt aPos) +/** +Inserts a signed integer into the array at the specified position. + +@param anEntry The signed integer to be inserted. +@param aPos The position within the array where the signed integer is to be + inserted. The position is relative to zero, i.e. zero implies + that an entry is inserted at the beginning of the array. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. + +@panic USER 131, if aPos is negative, or is greater than the number of entries + currently in the array. +*/ + { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); } + + + + +inline void RArray::Remove(TInt anIndex) +/** +Removes the signed integer at the specified position from the array. + +@param anIndex The position within the array from where the signed integer + is to be removed. The position is relative to zero, i.e. zero + implies that an entry at the beginning of the array is to be + removed. + +@panic USER 130, if anIndex is negative or is greater than the number of + entries currently in the array. +*/ + {RPointerArrayBase::Remove(anIndex);} + + + + +inline void RArray::Compress() +/** +Compresses the array down to a minimum. + +After a call to this function, the memory allocated to the array is just +sufficient for its entries. Subsequently adding a new signed integer to the +array always results in a re-allocation of memory. +*/ + {RPointerArrayBase::Compress();} + + + + +inline void RArray::Reset() +/** +Empties the array. + +The function frees all memory allocated to the array and +resets the internal state so that it is ready to be reused. + +This array object can be allowed to go out of scope after a call to this +function. +*/ + {RPointerArrayBase::Reset();} + + + + +inline TInt RArray::Find(TInt anEntry) const +/** +Finds the first signed integer in the array which matches the specified signed +integer using a sequential search. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of entries in the array. + +@param anEntry The signed integer to be found. + +@return The index of the first matching signed integer within the array. + KErrNotFound, if no matching entry can be found. +*/ + { return RPointerArrayBase::Find((const TAny*)anEntry); } + + + + +inline TInt RArray::FindReverse(TInt anEntry) const +/** +Finds the last signed integer in the array which matches the specified signed +integer using a sequential search. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of entries in the array. + +@param anEntry The signed integer to be found. + +@return The index of the last matching signed integer within the array. + KErrNotFound, if no matching entry can be found. +*/ + { return RPointerArrayBase::FindReverse((const TAny*)anEntry); } + + + + +inline TInt RArray::FindInOrder(TInt anEntry) const +/** +Finds the signed integer in the array that matches the specified signed integer +using a binary search technique. + +The function assumes that the array is in signed integer order. + +@param anEntry The signed integer to find. + +@return The index of the matching signed integer within the array or KErrNotFound, + if no match can be found. +*/ + { return RPointerArrayBase::FindIsqSigned(anEntry); } + + + + +inline TInt RArray::FindInOrder(TInt anEntry, TInt& anIndex) const +/** +Finds the signed integer in the array that matches the specified signed integer +using a binary search technique. + +The function assumes that the array is in signed integer order. + +@param anEntry The signed integer to find. +@param anIndex A TInt suplied by the caller. On return contains an index value. + If the function returns KErrNone, this is the index of the + matching signed integer within the array. + If the function returns KErrNotFound, this is the index of the + first signed integer within the array that is bigger than the + signed integer being searched for - if no signed integers within + the array are bigger, then the index value is the same as the + total number of signed integers within the array. + +@return KErrNone if a matching signed integer is found. + KErrNotFound if no match can be found. +*/ + { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex); } + + + + +inline TInt RArray::SpecificFindInOrder(TInt anEntry, TInt aMode) const +/** +Finds the signed integer in the array that matches the specified signed integer +using a binary search technique. + +Where there is more than one matching element, it finds the first, last or any +matching element as specified by the value of aMode. + +The function assumes that the array is in signed integer order. + +@param anEntry The signed integer to be found. +@param aMode Specifies whether to find the first match, the last match or any + match, as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array + index of a matching element - what the index refers to depends on the + value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element + of the array, then the index value is the same as the total number of elements in + the array. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::FindIsqSigned(anEntry,aMode); } + + + + +inline TInt RArray::SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the signed integer in the array that matches the specified signed integer +using a binary search technique. + +Where there is more than one matching element, it finds the first, last or any +matching element as specified by the value of aMode. + +The function assumes that the array is in signed integer order. + +@param anEntry The signed integer to be found. +@param anIndex A TInt type supplied by the caller. On return, it contains an index + value depending on whether a match is found and on the value of aMode. + If there is no matching element in the array, then this is the index of + the first element in the array that is bigger than the element being + searched for - if no elements in the array are bigger, then the index + value is the same as the total number of elements in the array. + If there is a matching element, then what the index refers to depends + on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element + of the array, then the index value is the same as the total number of elements in the array. + +@param aMode Specifies whether to find the first match, the last match or any match, + as defined by one of the TArrayFindMode enum values. + +@return KErrNone, if a matching element is found; + KErrNotFound, if no suitable element can be found. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::BinarySearchSigned(anEntry,anIndex,aMode); } + + + + +inline TInt RArray::InsertInOrder(TInt anEntry) +/** +Inserts a signed integer into the array in signed integer order. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that existing entries within the array are in signed +integer order. + +@param anEntry The signed integer to be inserted + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + { return RPointerArrayBase::InsertIsqSigned(anEntry,EFalse); } + + + + +inline TInt RArray::InsertInOrderAllowRepeats(TInt anEntry) +/** +Inserts a signed integer into the array in signed integer order, +allowing duplicates. + +If anEntry is a duplicate of an existing entry in the array, then the new +signed integer is inserted after the existing one. If more than one duplicate +entry already exists in the array, then any new duplicate signed integer is +inserted after the last one. + +The function assumes that existing entries within the array are in signed +integer order. + +@param anEntry The signed integer to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::InsertIsqSigned(anEntry,ETrue); } + + + + +#ifndef __KERNEL_MODE__ +inline RArray::RArray(TInt* aEntries, TInt aCount) + : RPointerArrayBase((TAny**)aEntries, aCount) +/** +C++ constructor with a pointer to the first array entry in a +pre-existing array, and the number of entries in that array. + +This constructor takes a pointer to a pre-existing set of entries of type +TInt objects. Ownership of the set of entries does not transfer to +this RArray object. + +The purpose of constructing an array in this way is to allow sorting and +finding operations to be done without further allocation of memory. + +@param aEntries A pointer to the first entry of type class TInt in the set of + entries belonging to the existing array. +@param aCount The number of entries in the existing array. +*/ + {} + +inline void RArray::GranularCompress() +/** +Compresses the array down to a granular boundary. + +After a call to this function, the memory allocated to the array is sufficient +for its contained entries. Adding new signed integers to the array does not +result in a re-allocation of memory until the total number of entries reaches +a multiple of the granularity. +*/ + {RPointerArrayBase::GranularCompress();} + + + + +inline TInt RArray::Reserve(TInt aCount) +/** +Reserves space for the specified number of elements. + +After a call to this function, the memory allocated to the array is sufficient +to hold the number of integers specified. Adding new integers to the array +does not result in a re-allocation of memory until the the total number of +integers exceeds the specified count. + +@param aCount The number of integers for which space should be reserved +@return KErrNone If the operation completed successfully +@return KErrNoMemory If the requested amount of memory could not be allocated +*/ + { return RPointerArrayBase::DoReserve(aCount); } + + + + +inline void RArray::Sort() +/** +Sorts the array entries into signed integer order. +*/ + { HeapSortSigned(); } + + + + +inline TArray RArray::Array() const +/** +Constructs and returns a generic array. + +@return A generic array representing this array. + +@see TArray +*/ + { return TArray(GetCount,GetElementPtr,(const CBase*)this); } +#endif + + + +inline RArray::RArray() + : RPointerArrayBase() +/** +Default C++ constructor. + +This constructs an array object for an array of unsigned +integers with default granularity. + +The default granularity of the array is 8. +*/ + {} + + + + +inline RArray::RArray(TInt aGranularity) + : RPointerArrayBase(aGranularity) +/** +Constructs an array object for an array of unsigned integers with the specified +granularity. + +@param aGranularity The granularity of the array. + +@panic USER 127, if aGranularity is not positive or is greater than or + equal to 0x10000000. +*/ + {} + + + + +/** +C++ constructor with minimum growth step and exponential growth factor. + +This constructs an array object for an array of unsigned integers with the +specified minimum growth step and exponential growth factor. + +@param aMinGrowBy The minimum growth step of the array. Must be between 1 and + 65535 inclusive. +@param aFactor The factor by which the array grows, multiplied by 256. + For example 512 specifies a factor of 2. Must be between 257 + and 32767 inclusive. + +@panic USER 192, if aMinGrowBy<=0 or aMinGrowBy>65535. +@panic USER 193, if aFactor<=257 or aFactor>32767. +*/ +inline RArray::RArray(TInt aMinGrowBy, TInt aFactor) + : RPointerArrayBase(aMinGrowBy, aFactor) + {} + + + + +inline void RArray::Close() +/** +Closes the array and frees all memory allocated to the array. + +The function must be called before this array object goes out of scope. +*/ + {RPointerArrayBase::Close();} + + + + +inline TInt RArray::Count() const +/** +Gets the number of unsigned integers in the array. + +@return The number of unsigned integers in the array. +*/ + {return RPointerArrayBase::Count(); } + + + + +inline const TUint& RArray::operator[](TInt anIndex) const +/** +Gets a reference to the unsigned integer located at the specified position +within the array. + +The compiler uses this variant if the returned reference is used in an +expression where the reference cannot be modified. + +@param anIndex The position of the unsigned integer within the array, relative + to zero, i.e. zero implies the entry at the beginning of + the array. + +@return A reference to the const unsigned integer at position anIndex within + the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + entries currently in the array. +*/ + {return (const TUint&)At(anIndex);} + + + + +inline TUint& RArray::operator[](TInt anIndex) +/** +Gets a reference to the unsigned integer located at the specified position +within the array. + +The compiler uses this variant if the returned reference is used in an +expression where the reference can be modified. + +@param anIndex The position of the unsigned integer within the array, relative + to zero, i.e. zero implies the entry at the beginning of + the array. + +@return A reference to the non-const unsigned integer at position anIndex + within the array. + +@panic USER 130, if anIndex is negative, or is greater than the number of + entries currently in the array. +*/ + {return (TUint&)At(anIndex);} + + + + +inline TInt RArray::Append(TUint anEntry) +/** +Appends an unsigned integer onto the array. + +@param anEntry The unsigned integer to be appended. +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::Append((const TAny*)anEntry); } + + + + +inline TInt RArray::Insert(TUint anEntry, TInt aPos) +/** +Inserts an unsigned integer into the array at the specified position. + +@param anEntry The unsigned integer to be inserted. +@param aPos The position within the array where the unsigned integer is to + be inserted. The position is relative to zero, i.e. zero + implies that an entry is inserted at the beginning of + the array. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. + +@panic USER 131, if aPos is negative, or is greater than the number of entries + currently in the array. +*/ + { return RPointerArrayBase::Insert((const TAny*)anEntry,aPos); } + + + + +inline void RArray::Remove(TInt anIndex) +/** +Removes the unsigned integer at the specified position from the array. + +@param anIndex The position within the array from where the unsigned integer + is to be removed. The position is relative to zero, i.e. zero + implies that an entry at the beginning of the array is to be + removed. + + +@panic USER 130, if anIndex is negative, or is greater than the number of + entries currently in the array. +*/ + {RPointerArrayBase::Remove(anIndex);} + + + + +inline void RArray::Compress() +/** +Compresses the array down to a minimum. + +After a call to this function, the memory allocated to the array is just +sufficient for its entries. Subsequently adding a new unsigned integer to the +array always results in a re-allocation of memory. +*/ + {RPointerArrayBase::Compress();} + + + + +inline void RArray::Reset() +/** +Empties the array. + +It frees all memory allocated to the array and resets the +internal state so that it is ready to be reused. + +This array object can be allowed to go out of scope after a call to +this function. +*/ + {RPointerArrayBase::Reset();} + + + + +inline TInt RArray::Find(TUint anEntry) const +/** +Finds the first unsigned integer in the array which matches the specified +value, using a sequential search. + +The find operation always starts at the low index end of the array. There +is no assumption about the order of entries in the array. + +@param anEntry The unsigned integer to be found. + +@return The index of the first matching unsigned integer within the array. + KErrNotFound, if no matching entry can be found. +*/ + { return RPointerArrayBase::Find((const TAny*)anEntry); } + + + + +inline TInt RArray::FindReverse(TUint anEntry) const +/** +Finds the last unsigned integer in the array which matches the specified +value, using a sequential search. + +The find operation always starts at the high index end of the array. There +is no assumption about the order of entries in the array. + +@param anEntry The unsigned integer to be found. + +@return The index of the last matching unsigned integer within the array. + KErrNotFound, if no matching entry can be found. +*/ + { return RPointerArrayBase::FindReverse((const TAny*)anEntry); } + + + + +inline TInt RArray::FindInOrder(TUint anEntry) const +/** +Finds the unsigned integer in the array which matches the specified value, +using a binary search technique. + +The functions assume that existing entries within the array are in unsigned +integer order. + +@param anEntry The unsigned integer to be found. + +@return This is either: the index of the matching unsigned integer within the + array; + KErrNotFound, if no suitable entry can be found. +*/ + { return RPointerArrayBase::FindIsqUnsigned(anEntry); } + + + + +inline TInt RArray::FindInOrder(TUint anEntry, TInt& anIndex) const +/** +Finds the unsigned integer in the array which matches the specified value, +using a binary search technique. + +If the index cannot be found, the function returns the index of the last +unsigned integer within the array which logically precedes anEntry. + +The functions assume that existing entries within the array are in unsigned +integer order. + +@param anEntry The unsigned integer to be found. +@param anIndex A TInt supplied by the caller. On return, contains an index + value. + If the function returns KErrNone, this is the index of the + matching unsigned integer within the array. + If the function returns KErrNotFound, this is the index of the + first unsigned integer within the array that is bigger than the + unsigned integer being searched for - if no unsigned integers within + the array are bigger, then the index value is the same as the + total number of unsigned integers within the array. +@return KErrNone, if a matching unsigned integer is found. + KErrNotFound, if no suitable entry can be found. +*/ + { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex); } + + + + +inline TInt RArray::SpecificFindInOrder(TUint anEntry, TInt aMode) const +/** +Finds the unsigned integer in the array that matches the specified unsigned integer +using a binary search technique. + +In the case that there is more than one matching element, finds the first, last +or any match as specified by the value of aMode. + +The function assumes that the array is in unsigned integer order. + +@param anEntry The unsigned integer to be found.. +@param aMode Specifies whether to find the first match, the last match or any match, + as defined by one of the TArrayFindMode enum values. + +@return KErrNotFound, if there is no matching element, otherwise the array index of + a matching element - what the index refers to depends on the value of + aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of + the array, then the index value is the same as the total number of elements in the array. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::FindIsqUnsigned(anEntry,aMode); } + + + + +inline TInt RArray::SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const +/** +Finds the unsigned integer in the array that matches the specified unsigned integer +using a binary search technique. + +In the case that there is more than one matching element, finds the first, last or any match as specified. + +The function assumes that the array is in unsigned integer order. + +@param anEntry The unsigned integer to be found. +@param anIndex A TInt type supplied by the caller. On return, it contains an index + value depending on whether a match is found and on the value of aMode. + If there is no matching element in the array, then this is the index + of the first element in the array that is bigger than the element being + searched for - if no elements in the array are bigger, then the index + value is the same as the total number of elements in the array. + If there is a matching element, then what the index refers to depends + on the value of aMode: + if this is EArrayFindMode_First, then the index refers to the first matching element; + if this is EArrayFindMode_Any, then the index can refer to any of the matching elements; + if this is EArrayFindMode_Last, then the index refers to first element that follows + the last matching element - if the last matching element is also the last element of the array, + then the index value is the same as the total number of elements in the array. +@param aMode Specifies whether to find the first match, the last match or any match, as defined by one + of the TArrayFindMode enum values. + +@return KErrNone, if a matching entry is found; KErrNotFound, if no matching entry exists. + +@see TArrayFindMode +*/ + { return RPointerArrayBase::BinarySearchUnsigned(anEntry,anIndex,aMode); } + + + + +inline TInt RArray::InsertInOrder(TUint anEntry) +/** +Inserts an unsigned integer into the array in unsigned integer order. + +No duplicate entries are permitted. The array remains unchanged following +an attempt to insert a duplicate entry. + +The function assumes that existing entries within the array are in unsigned +integer order. + +@param anEntry The unsigned integer to be inserted. + +@return KErrNone, if the insertion is successful; + KErrAlreadyExists, if an attempt is being made + to insert a duplicate entry; otherwise one of the other system wide + error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned(anEntry,EFalse); } + + + + +inline TInt RArray::InsertInOrderAllowRepeats(TUint anEntry) +/** +Inserts an unsigned integer into the array in unsigned integer order, allowing +duplicates. + +If the new integer is a duplicate of an existing entry in the array, then +the new unsigned integer is inserted after the existing one. If more than +one duplicate entry already exists in the array, then any new duplicate +unsigned integer is inserted after the last one. + +The function assumes that existing entries within the array are in unsigned +integer order. + +@param anEntry The unsigned integer to be inserted. + +@return KErrNone, if the insertion is successful, otherwise one of the system + wide error codes. +*/ + { return RPointerArrayBase::InsertIsqUnsigned(anEntry,ETrue); } + + + + +#ifndef __KERNEL_MODE__ +inline RArray::RArray(TUint* aEntries, TInt aCount) + : RPointerArrayBase((TAny**)aEntries, aCount) +/** +C++ constructor with a pointer to the first array entry in a +pre-existing array, and the number of entries in that array. + +This constructor takes a pointer to a pre-existing set of entries of type +TUint objects. Ownership of the set of entries does not transfer to +this RArray object. + +The purpose of constructing an array in this way is to allow sorting and +finding operations to be done without further allocation of memory. + +@param aEntries A pointer to the first entry of type class TUint in the set of + entries belonging to the existing array. +@param aCount The number of entries in the existing array. +*/ + {} + + + +inline void RArray::GranularCompress() +/** +Compresses the array down to a granular boundary. + +After a call to this function, the memory allocated to the array is sufficient +for its contained entries. Adding new unsigned integers to the array does not +result in a re-allocation of memory until the total number of entries reaches +a multiple of the granularity. +*/ + {RPointerArrayBase::GranularCompress();} + + + + +inline TInt RArray::Reserve(TInt aCount) +/** +Reserves space for the specified number of elements. + +After a call to this function, the memory allocated to the array is sufficient +to hold the number of integers specified. Adding new integers to the array +does not result in a re-allocation of memory until the the total number of +integers exceeds the specified count. + +@param aCount The number of integers for which space should be reserved +@return KErrNone If the operation completed successfully +@return KErrNoMemory If the requested amount of memory could not be allocated +*/ + { return RPointerArrayBase::DoReserve(aCount); } + + + + +inline void RArray::Sort() +/** +Sorts the array entries into unsigned integer order. +*/ + { HeapSortUnsigned(); } + + + + +inline TArray RArray::Array() const +/** +Constructs and returns a generic array. + +@return A generic array representing this array. + +@see TArray +*/ + { return TArray(GetCount,GetElementPtr,(const CBase*)this); } +#endif + + + + +/** +Sets an argument to default value and type. +*/ +inline void TIpcArgs::Set(TInt,TNothing) + {} + + + + +/** +Sets an argument value of TInt type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,TInt aValue) + { + iArgs[aIndex] = aValue; + iFlags |= EUnspecified<<(aIndex*KBitsPerType); + } + + + + +/** +Sets an argument value of TAny* type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,const TAny* aValue) + { + iArgs[aIndex] = (TInt)aValue; + iFlags |= EUnspecified<<(aIndex*KBitsPerType); + } + + + + +/** +Sets an argument value of RHandleBase type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,RHandleBase aValue) + { + iArgs[aIndex] = (TInt)aValue.Handle(); + iFlags |= EHandle<<(aIndex*KBitsPerType); + } + + + + +/** +Sets an argument value TDesC8* type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,const TDesC8* aValue) + { + iArgs[aIndex] = (TInt)aValue; + iFlags |= EDesC8<<(aIndex*KBitsPerType); + } + + + + +#ifndef __KERNEL_MODE__ + +/** +Sets an argument value of TDesC16* type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,const TDesC16* aValue) + { + iArgs[aIndex] = (TInt)aValue; + iFlags |= EDesC16<<(aIndex*KBitsPerType); + } + +#endif + + + + +/** +Sets an argument value of TDes8* type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,TDes8* aValue) + { + iArgs[aIndex] = (TInt)aValue; + iFlags |= EDes8<<(aIndex*KBitsPerType); + } + + + + +#ifndef __KERNEL_MODE__ + +/** +Sets an argument value of TDes16* type. + +@param aIndex An index value that identifies the slot in the array of arguments + into which the argument value is to be placed. + This must be a value in the range 0 to 3. +@param aValue The argument value. +*/ +inline void TIpcArgs::Set(TInt aIndex,TDes16* aValue) + { + iArgs[aIndex] = (TInt)aValue; + iFlags |= EDes16<<(aIndex*KBitsPerType); + } + +#endif + + + + +inline TIpcArgs::TArgType TIpcArgs::Type(TNothing) + { return EUnspecified; } +inline TIpcArgs::TArgType TIpcArgs::Type(TInt) + { return EUnspecified; } +inline TIpcArgs::TArgType TIpcArgs::Type(const TAny*) + { return EUnspecified; } +inline TIpcArgs::TArgType TIpcArgs::Type(RHandleBase) + { return EHandle; } +inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC8*) + { return EDesC8; } +#ifndef __KERNEL_MODE__ +inline TIpcArgs::TArgType TIpcArgs::Type(const TDesC16*) + { return EDesC16; } +#endif +inline TIpcArgs::TArgType TIpcArgs::Type(TDes8*) + { return EDes8; } +#ifndef __KERNEL_MODE__ +inline TIpcArgs::TArgType TIpcArgs::Type(TDes16*) + { return EDes16; } +#endif +inline void TIpcArgs::Assign(TInt&,TIpcArgs::TNothing) + {} +inline void TIpcArgs::Assign(TInt& aArg,TInt aValue) + { aArg = aValue; } +inline void TIpcArgs::Assign(TInt& aArg,const TAny* aValue) + { aArg = (TInt)aValue; } +inline void TIpcArgs::Assign(TInt& aArg,RHandleBase aValue) + { aArg = (TInt)aValue.Handle(); } +inline void TIpcArgs::Assign(TInt& aArg,const TDesC8* aValue) + { aArg = (TInt)aValue; } +#ifndef __KERNEL_MODE__ +inline void TIpcArgs::Assign(TInt& aArg,const TDesC16* aValue) + { aArg = (TInt)aValue; } +#endif +inline void TIpcArgs::Assign(TInt& aArg,TDes8* aValue) + { aArg = (TInt)aValue; } +#ifndef __KERNEL_MODE__ +inline void TIpcArgs::Assign(TInt& aArg,TDes16* aValue) + { aArg = (TInt)aValue; } +#endif + + + +// Structures for passing 64 bit integers and doubles across GCC/EABI boundaries + +inline SInt64::SInt64() + {} + +inline SInt64::SInt64(Int64 a) + { + iData[0] = (TUint32)((Uint64)a); + iData[1] = (TUint32)(((Uint64)a)>>32); + } + +inline SInt64& SInt64::operator=(Int64 a) + { + iData[0] = (TUint32)((Uint64)a); + iData[1] = (TUint32)(((Uint64)a)>>32); + return *this; + } + +inline SInt64::operator Int64() const + { + Int64 x; + TUint32* px = (TUint32*)&x; + px[0] = iData[0]; + px[1] = iData[1]; + return x; + } + +inline SUint64::SUint64() + {} + +inline SUint64::SUint64(Uint64 a) + { + iData[0] = (TUint32)a; + iData[1] = (TUint32)(a>>32); + } + +inline SUint64& SUint64::operator=(Uint64 a) + { + iData[0] = (TUint32)a; + iData[1] = (TUint32)(a>>32); + return *this; + } + +inline SUint64::operator Uint64() const + { + Uint64 x; + TUint32* px = (TUint32*)&x; + px[0] = iData[0]; + px[1] = iData[1]; + return x; + } + +inline SDouble::SDouble() + {} + +inline SDouble::SDouble(TReal a) + { + const TUint32* pa = (const TUint32*)&a; +#ifdef __DOUBLE_WORDS_SWAPPED__ + iData[0] = pa[1]; + iData[1] = pa[0]; // compiler puts MS word of double first +#else + iData[0] = pa[0]; + iData[1] = pa[1]; // compiler puts MS word of double second +#endif + } + +inline SDouble& SDouble::operator=(TReal a) + { + new (this) SDouble(a); + return *this; + } + +inline SDouble::operator TReal() const + { + TReal x; + TUint32* px = (TUint32*)&x; +#ifdef __DOUBLE_WORDS_SWAPPED__ + px[1] = iData[0]; + px[0] = iData[1]; // compiler puts MS word of double first +#else + px[0] = iData[0]; + px[1] = iData[1]; // compiler puts MS word of double second +#endif + return x; + } + +// +// TSecureId +// + +/** Default constructor. This leaves the object in an undefined state */ +inline TSecureId::TSecureId() + {} + +/** Construct 'this' using a TUint32 +@param aId The value for the ID */ +inline TSecureId::TSecureId(TUint32 aId) + : iId(aId) {} + +/** Convert 'this' into a TUint32 +*/ +inline TSecureId::operator TUint32() const + { return iId; } + +/** Construct 'this' using a TUid +@param aId The value for the ID */ +inline TSecureId::TSecureId(TUid aId) + : iId(aId.iUid) {} + +/** Convert 'this' into a TUid +*/ +inline TSecureId::operator TUid() const + { return (TUid&)iId; } + +// +// SSecureId +// +inline const TSecureId* SSecureId::operator&() const + { return (const TSecureId*)this; } +inline SSecureId::operator const TSecureId&() const + { return (const TSecureId&)iId; } +inline SSecureId::operator TUint32() const + { return iId; } +inline SSecureId::operator TUid() const + { return (TUid&)iId; } + +// +// TVendorId +// + +/** Default constructor which leaves the object in an undefined state */ +inline TVendorId::TVendorId() + {} + +/** Construct 'this' using a TUint32 +@param aId The value for the ID */ +inline TVendorId::TVendorId(TUint32 aId) + : iId(aId) {} + +/** Convert 'this' into a TUint32 +*/ +inline TVendorId::operator TUint32() const + { return iId; } + +/** Construct 'this' using a TUid +@param aId The value for the ID */ +inline TVendorId::TVendorId(TUid aId) + : iId(aId.iUid) {} + +/** Convert 'this' into a TUid +*/ +inline TVendorId::operator TUid() const + { return (TUid&)iId; } + +// +// SSecureId +// +inline const TVendorId* SVendorId::operator&() const + { return (const TVendorId*)this; } +inline SVendorId::operator const TVendorId&() const + { return (const TVendorId&)iId; } +inline SVendorId::operator TUint32() const + { return iId; } +inline SVendorId::operator TUid() const + { return (TUid&)iId; } + +// +// TSharedChunkBufConfigBase +// +inline TSharedChunkBufConfigBase::TSharedChunkBufConfigBase() + {memset(this,0,sizeof(TSharedChunkBufConfigBase));} + +/** +Default constructor. This leaves the set in an undefned state. +*/ +inline TCapabilitySet::TCapabilitySet() + {} + +/** +Construct a set consisting of a single capability. +@param aCapability The single capability +*/ +inline TCapabilitySet::TCapabilitySet(TCapability aCapability) + { new (this) TCapabilitySet(aCapability, aCapability); } + +/** +Make this set consist of a single capability. +@param aCapability The single capability. +*/ +inline void TCapabilitySet::Set(TCapability aCapability) + { new (this) TCapabilitySet(aCapability, aCapability); } + +/** +Make this set consist of two capabilities. +@param aCapability1 The first capability. +@param aCapability2 The second capability. +*/ +inline void TCapabilitySet::Set(TCapability aCapability1, TCapability aCapability2) + { new (this) TCapabilitySet(aCapability1, aCapability2); } + + +/** +Default constructor. This leaves the object in an undefned state. +*/ +inline TSecurityInfo::TSecurityInfo() + {} + +/** Constructs a TSecurityPolicy that will always fail, irrespective of the +checked object's attributes. +*/ +inline TSecurityPolicy::TSecurityPolicy() + { new (this) TSecurityPolicy(EAlwaysFail); } + +/** +'Address of' operator which generates a TSecurityPolicy* +@return A pointer of type TSecurityPolicy which refers to this object +*/ +inline const TSecurityPolicy* TStaticSecurityPolicy::operator&() const + { return (const TSecurityPolicy*)this; } + +/** +'Reference of' operator which generates a TSecurityPolicy& +@return A reference of type TSecurityPolicy which refers to this object +*/ +inline TStaticSecurityPolicy::operator const TSecurityPolicy&() const + { return *(const TSecurityPolicy*)this; } + +/** +A method to explicity generate a TSecurityPolicy reference. +@return A reference of type TSecurityPolicy which refers to this object +*/ +inline const TSecurityPolicy& TStaticSecurityPolicy::operator()() const + { return *(const TSecurityPolicy*)this; } + +#ifdef __KERNEL_MODE__ +#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ + +/** Checks this policy against the platform security attributes of aProcess. + + When a check fails the action taken is determined by the system wide Platform Security + configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. + If PlatSecEnforcement is OFF, then this function will return ETrue even though the + check failed. + +@param aProcess The DProcess object to check against this TSecurityPolicy. +@param aDiagnostic A string that will be emitted along with any diagnostic message + that may be issued if the policy check fails. + This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro + which enables it to be easily removed from the system. +@return ETrue if all the requirements of this TSecurityPolicy are met by the +platform security attributes of aProcess, EFalse otherwise. +@panic KERN-COMMON 190 if 'this' is an invalid SSecurityInfo object +*/ +inline TBool TSecurityPolicy::CheckPolicy(DProcess* aProcess, const char* aDiagnostic) const + { + return DoCheckPolicy(aProcess, aDiagnostic); + } + +/** Checks this policy against the platform security attributes of the process +owning aThread. + + When a check fails the action taken is determined by the system wide Platform Security + configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. + If PlatSecEnforcement is OFF, then this function will return ETrue even though the + check failed. + +@param aThread The thread whose owning process' platform security attributes +are to be checked against this TSecurityPolicy. +@param aDiagnostic A string that will be emitted along with any diagnostic message + that may be issued if the policy check fails. + This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro + which enables it to be easily removed from the system. +@return ETrue if all the requirements of this TSecurityPolicy are met by the +platform security parameters of the owning process of aThread, EFalse otherwise. +@panic KERN-COMMON 190 if 'this' is an invalid SSecurityInfo object +*/ +inline TBool TSecurityPolicy::CheckPolicy(DThread* aThread, const char* aDiagnostic) const + { + return DoCheckPolicy(aThread, aDiagnostic); + } + +#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ + +/** Checks this policy against the platform security attributes of aProcess. + + When a check fails the action taken is determined by the system wide Platform Security + configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. + If PlatSecEnforcement is OFF, then this function will return ETrue even though the + check failed. + +@param aProcess The DProcess object to check against this TSecurityPolicy. +@param aDiagnostic A string that will be emitted along with any diagnostic message + that may be issued if the policy check fails. + This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro + which enables it to be easily removed from the system. +@return ETrue if all the requirements of this TSecurityPolicy are met by the +platform security attributes of aProcess, EFalse otherwise. +@panic KERN-COMMON 190 if 'this' is an invalid SSecurityInfo object +*/ +inline TBool TSecurityPolicy::CheckPolicy(DProcess* aProcess, OnlyCreateWithNull /*aDiagnostic*/) const + { + return DoCheckPolicy(aProcess); + } + +/** Checks this policy against the platform security attributes of the process +owning aThread. + + When a check fails the action taken is determined by the system wide Platform Security + configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. + If PlatSecEnforcement is OFF, then this function will return ETrue even though the + check failed. + +@param aThread The thread whose owning process' platform security attributes +are to be checked against this TSecurityPolicy. +@param aDiagnostic A string that will be emitted along with any diagnostic message + that may be issued if the policy check fails. + This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro + which enables it to be easily removed from the system. +@return ETrue if all the requirements of this TSecurityPolicy are met by the +platform security parameters of the owning process of aThread, EFalse otherwise. +@panic KERN-COMMON 190 if 'this' is an invalid SSecurityInfo object +*/ +inline TBool TSecurityPolicy::CheckPolicy(DThread* aThread, OnlyCreateWithNull /*aDiagnostic*/) const + { + return DoCheckPolicy(aThread); + } + +#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ +#endif // __KERNEL_MODE__