// 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 "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-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 <class T>

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

	: iRef(aRef)

/**

Constructs this value reference for the specified referenced object.

@param aRef The referenced object.

*/

	{}

template <class T>

inline TRefByValue<T>::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 <TInt S>

inline TBufC8<S>::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 <TInt S>

inline TBufC8<S>::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 <TInt S>

inline TBufC8<S>::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 <TInt S>

inline TBufC8<S> &TBufC8<S>::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 <TInt S>

inline TBufC8<S> &TBufC8<S>::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 <TInt S>

inline TPtr8 TBufC8<S>::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<const TDesC8&>(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.