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