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