// 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\e32std.inl

// 

//

// Global leaving operator new

inline TAny* operator new(TUint aSize, TLeave)

	{return User::AllocL(aSize);}

inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize)

	{return User::AllocL(aSize + aExtraSize);}

#if !defined(__VC32__) || defined (__MSVCDOTNET__)

inline TAny* operator new[](TUint aSize, TLeave)

	{return User::AllocL(aSize);}

#endif

// class Mem

inline TUint8* Mem::Copy(TAny* aTrg, const TAny* aSrc, TInt aLength)

/**

Copies data from a source location to a target location and returns a pointer 

to the end of the copied data.

The source and target areas can overlap.

The copy operation is optimised so that if both source and target locations 

are aligned on a word boundary, the operation performs the copy on a word 

by word basis.

@param aTrg    A pointer to the target location for the copy operation. 

@param aSrc    A pointer to the source location for the copy operation. 

@param aLength The number of bytes to be copied. This value must not

               be negative. 

@return A pointer to a location aLength bytes beyond aTrg (i.e. the location 

        aTrg+aLength).

@panic USER 90 In debug builds only, if aLength is negative. 

*/

	{ return (TUint8*)memmove(aTrg, aSrc, aLength) + aLength; }

inline TUint8* Mem::Move(TAny* aTrg, const TAny* aSrc, TInt aLength)

/**

Moves a block of data from a source location to a target location and returns 

a pointer to the end of the moved data.

The source and target areas can overlap.

Both source and target locations must be aligned on a word boundary. 

The specified length must also be a multiple of 4.

@param aTrg    A pointer to the target location for the move operation. This 

               pointer must be word aligned. 

@param aSrc    A pointer to the source location for the move operation. This

               pointer must be word aligned.

@param aLength The number of bytes to be copied. This value must be a multiple 

               of 4.

@return A pointer to a location aLength bytes beyond aTrg (i.e. the location 

        aTrg+aLength).

@panic USER 93 In debug builds only, if aTrg is not word aligned.

@panic USER 92 In debug builds only, if aSrc is not word aligned.

@panic USER 91 In debug builds only, if aLength is not a multiple of 4.

*/

	{ return (TUint8*)wordmove(aTrg, aSrc, aLength) + aLength; }

inline void Mem::Fill(TAny* aTrg, TInt aLength, TChar aChar)

/**

Fills a specified block of data with a specified character, replacing

any existing content.

The function assumes that the fill character is a non-Unicode character.

@param aTrg    A pointer to the location where filling is to start. 

@param aLength The number of bytes to be filled. This value must not

               be negative. 

@param aChar   The fill character.

@panic USER 95 In debug builds only, if aLength is negative.  

*/

	{ memset(aTrg, (TInt)(aChar.operator TUint()), aLength); }

inline void Mem::FillZ(TAny* aTrg,TInt aLength)

/**

Fills a specified block of data with binary zeroes (i.e. 0x00), replacing any 

existing content.

@param aTrg    A pointer to the location where filling is to start. 

@param aLength The number of bytes to be filled. This value must not

               be negative. 

@panic USER 95 In debug builds only, if aLength is negative.  

*/

	{ memclr(aTrg, aLength); }

#if !(defined(__GCC32__) && defined(__MARM__))

inline TInt Mem::Compare(const TUint8* aLeft, TInt aLeftL, const TUint8* aRight, TInt aRightL)

/**

Compares a block of data at one specified location with a block of data at 

another specified location.

The comparison proceeds on a byte for byte basis, the result of the comparison 

is based on the difference of the first bytes to disagree.

The data at the two locations are equal if they have the same length and content. 

Where the lengths are different and the shorter section of data is the same 

as the first part of the longer section of data, the shorter is considered 

to be less than the longer.

@param aLeft   A pointer to the first (or left) block of 8 bit data

               to be compared.

@param aLeftL  The length of the first (or left) block of data to be compared,  

               i.e. the number of bytes.

@param aRight  A pointer to the second (or right) block of 8 bit data to be 

               compared.

@param aRightL The length of the second (or right) block of data to be compared 

               i.e. the number of bytes.

@return Positive, if the first (or left) block of data is greater than the 

        second (or right) block of data.

        Negative, if the first (or left) block of data is less than the

        second (or right) block of data.

        Zero, if both the first (or left) and second (or right) blocks of data

        have the same length and the same content.

*/

	{ return memcompare(aLeft, aLeftL, aRight, aRightL); }

#endif

// class RHeap

inline TInt RHeap::SetBrk(TInt aBrk)

	{ return ((RChunk*)&iChunkHandle)->Adjust(aBrk); }

// class TChar

#ifndef __KERNEL_MODE__

inline void TChar::SetChar(TUint aChar)

	{iChar=aChar;}

inline void TChar::Fold()

/**

Converts the character to a form which can be used in tolerant comparisons 

without control over the operations performed. 

Tolerant comparisons are those which ignore character differences like case 

and accents.

This function can be used when searching for a string in a text file or a 

file in a directory. Folding performs the following conversions: converts 

to lowercase, strips accents, converts all digits representing the values 

0..9 to the ordinary digit characters '0'..'9', converts all spaces (standard, 

non-break, fixed-width, ideographic, etc.) to the ordinary space character 

(0x0020), converts Japanese characters in the hiragana syllabary to katakana, 

and converts East Asian halfwidth and fullwidth variants to their ordinary 

forms. You can choose to perform any subset of these operations by using the 

other function overload.

@see User::Fold

*/

	{iChar=User::Fold(iChar);}

inline void TChar::LowerCase()

/**

Converts the character to its lowercase form.

Characters lacking a lowercase form are unchanged.

@see User::LowerCase

*/

	{iChar=User::LowerCase(iChar);}

inline void TChar::UpperCase()

/**

Converts the character to its uppercase form.

Characters lacking an uppercase form are unchanged.

@see User::UpperCase

*/

	{iChar=User::UpperCase(iChar);}

#ifdef _UNICODE

inline void TChar::Fold(TInt aFlags)

/**

Converts the character to a form which can be used in tolerant comparisons 

allowing selection of the specific fold operations to be performed.

@param aFlags Flags which define the operations to be performed. The values 

              are defined in the enum beginning with EFoldCase.

@see TChar::EFoldCase

@see User::Fold

*/

	{iChar=User::Fold(iChar,aFlags);}

inline void TChar::TitleCase()

/**

Converts the character to its titlecase form.

The titlecase form of a character is identical to its uppercase form unless 

a specific titlecase form exists. Characters lacking a titlecase form are 

unchanged.

*/

	{iChar=User::TitleCase(iChar);}

#endif

inline TBool TChar::Eos() const

/**

Tests whether the character is the C/C++ end-of-string character - 0.

@return True, if the character is 0; false, otherwise.

*/

	{return(iChar==0);}

inline TBool TChar::IsSupplementary(TUint aChar)

/**

@param aChar The 32-bit code point value of a Unicode character.

@return True, if aChar is supplementary character; false, otherwise.

*/

	{

	return (aChar > 0xFFFF);

	}

inline TBool TChar::IsSurrogate(TText16 aInt16)

/**

@return True, if aText16 is high surrogate or low surrogate; false, otherwise.

*/

	{

	return (aInt16 & 0xF800) == 0xD800;

	}

inline TBool TChar::IsHighSurrogate(TText16 aInt16)

/**

@return True, if aText16 is high surrogate; false, otherwise.

*/

	{

	return (aInt16 & 0xFC00) == 0xD800;

	}

inline TBool TChar::IsLowSurrogate(TText16 aInt16)

/**

@return True, if aText16 is low surrogate; false, otherwise.

*/

	{

	return (aInt16 & 0xFC00) == 0xDC00;

	}

inline TUint TChar::JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate)

/**

Combine a high surrogate and a low surrogate into a supplementary character.

@return The 32-bit code point value of the generated Unicode supplementary

        character.

*/

	{

	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;

	}

inline TText16 TChar::GetHighSurrogate(TUint aChar)

/**

Retrieve the high surrogate of a supplementary character.

@param aChar The 32-bit code point value of a Unicode character.

@return High surrogate of aChar, if aChar is a supplementary character; 

        aChar itself, if aChar is not a supplementary character.

@see TChar::GetLowSurrogate

*/

	{

	return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10));

	}

inline TText16 TChar::GetLowSurrogate(TUint aChar)

/**

Retrieve the low surrogate of a supplementary character.

@param aChar The 32-bit code point value of a Unicode character.

@return Low surrogate of aChar, if aChar is a supplementary character; 

        zero, if aChar is not a supplementary character.

@see TChar::GetHighSurrogate

*/

	{

	return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF));

	}

#endif // _UNICODE

// Class TCallBack

inline TCallBack::TCallBack()

/**

Default constructor.

Sets the function pointer to Null.

*/

	{iFunction=NULL;}

inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr))

	: iFunction(aFunction),iPtr(NULL)

/**

Constructs the callback object with the specified callback function.

@param aFunction A pointer to the callback function. It takes an argument of

                 type TAny* and returns a TInt.

				 It must be either a static member of a class or a function

				 which is not a member of any class. 

*/

	{}

inline TCallBack::TCallBack(TInt (*aFunction)(TAny *aPtr),TAny *aPtr)

	: iFunction(aFunction),iPtr(aPtr)

/**

Constructs the callback object with the specified callback function and

a pointer to any object.

@param aFunction A pointer to the callback function. It takes an argument of

                 type TAny* and returns a TInt.

				 It must be either a static member of a class or a function

				 which is not a member of any class. 

@param aPtr      A pointer which is always passed to the callback function.

*/

	{}

/**

Calls the callback function.

@return The value returned by the callback function. The meaning of this value

        depends entirely on the context in which the callback function

        is called.

        For example, when used with the CIdle class, a false (zero) value

        indicates that the callback function should not be 	called again.

        As another example, when used with the CPeriodic class, the return

        value is ignored and is irrelevant in that context.

@see CIdle

@see CPeriodic        

*/

inline TInt TCallBack::CallBack() const

	{ return (iFunction ? (*iFunction)(iPtr) : 0); }

// Class TSglQue

template <class T>

inline TSglQue<T>::TSglQue()

/**

Constructs an empty list header and sets the offset value of the link object 

to zero.

In practice, never assume that the offset of the link object from the start 

of a list element is zero, even if the link object is declared as the first 

data member in the list element class.

If this default constructor is used, then call the SetOffset() function of 

the base class to ensure that the offset value is set correctly.

@see TSglQueBase::SetOffset

*/

	{}

template <class T>

inline TSglQue<T>::TSglQue(TInt aOffset)

	: TSglQueBase(aOffset)

/**

Constructs an empty list header and sets the offset of the link object to the 

specified value.

@param aOffset The offset of the link object from the start of a list element. 

                The macro _FOFF can be used to calculate this value.

@panic USER 75, if aOffset is not divisible by four.

@see _FOFF

*/

	{}

template <class T>

inline void TSglQue<T>::AddFirst(T &aRef)

/**

Inserts the specified list element at the front of the singly linked list.

If the list is not empty, the specified element becomes the first in the list. 

What was previously the first element becomes the second in the list.

@param aRef The list element to be inserted at the front of the singly linked 

            list.

*/

	{DoAddFirst(&aRef);}

template <class T>

inline void TSglQue<T>::AddLast(T &aRef)

/**

Inserts the specified list element at the back of the singly linked list.

If the list is not empty, the specified element becomes the last in the list. 

What was previously the last element becomes the next to last element in the 

list.

@param aRef The list element to be inserted at the back of the singly linked 

            list.

*/

	{DoAddLast(&aRef);}

template <class T>

inline TBool TSglQue<T>::IsFirst(const T *aPtr) const

/**

Tests whether the specified element is the first in the singly linked list.

@param aPtr A pointer to the element whose position in the list is to be

            checked.

@return True, if the element is the first in the list; false, otherwise.

*/

	{return(PtrAdd(aPtr,iOffset)==(T *)iHead);}

template <class T>

inline TBool TSglQue<T>::IsLast(const T *aPtr) const

/**

Tests whether the specified element is the last in the singly linked list.

@param aPtr A pointer to the element whose position in the list is 

            to be checked.