// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

// Class TDbCol

inline TDbCol::TDbCol(const TDesC &aName)

	: iName(aName)

	{

	}

/**

TDbCol copy constructor.

@param aSrcCol This TDbCol object will be constructed as an exact copy of aSrcCol object.

*/

inline TDbCol::TDbCol(const TDbCol& aSrcCol) :

	iType(aSrcCol.iType),

	iMaxLength(aSrcCol.iMaxLength),

	iAttributes(aSrcCol.iAttributes),

	iName(static_cast <const TDesC&> (aSrcCol.iName))

	{

	}

/**

TDbCol "=" operator.

@param aSrcCol This TDbCol object will be made to be an exact copy of aSrcCol object.

*/

inline TDbCol& TDbCol::operator=(const TDbCol& aSrcCol)

	{

	iType = aSrcCol.iType;

	iMaxLength = aSrcCol.iMaxLength;

	iAttributes = aSrcCol.iAttributes;

	iName = static_cast <const TDesC&> (aSrcCol.iName);

	return *this;

	}

/** Tests if a column is of the Long column type, i.e. one of the EDbColLongXxxx 

types.

@param aType The column type to test.

@return ETrue if the aType is a Long column type, EFalse otherwise. */

inline TBool TDbCol::IsLong(TDbColType aType)

	{

	return aType>=EDbColLongText8;

	}

// Class CDbColSet

/** Returns the number of column definitions in the set.

Note that using a TDbColSetIter is another way to iterate through the contents 

of a CDbColSet.

@return The number of columns in the columns set. */

inline TInt CDbColSet::Count() const

	{

	return iColumns.Count();

	}

/** Removes all of the columns from the column set. */

inline void CDbColSet::Clear()

	{

	iColumns.Reset();

	}

/** Returns a column definition by its ordinal number in the set.

Note that using a TDbColSetIter is another way to iterate through the contents 

of a CDbColSet.

@param aCol The ordinal number of the column in the set. Columns in a column 

set are numbered from 1 to Count(), unlike Symbian OS array classes. Ordinal 

0 is reserved to represent the invalid column number KDbNullColNo.

@return The column definition requested. */

inline const TDbCol& CDbColSet::operator[](TDbColNo aCol) const

	{

	return iColumns[aCol-1];// 1-based column ids 

	}

// Class TDbColSetIter

inline TDbColSetIter::operator TAny* () const

	{

	return CONST_CAST(TDbCol*,iColumn);

	}

/** Dereferences the iterator on the current column definition.

@return A const reference to the current column definition. */

inline const TDbCol& TDbColSetIter::operator*() const

	{

	__ASSERT_DEBUG(iIndex<iArray->Count(),User::Invariant());

	return *iColumn;

	}

/** Gets a member of the currently referenced column definition. This enables the 

use of the following constructs:

if (iter->iType==EDbColText && iter->iMaxLength<50) 

@return A const pointer to the current column definition. */

inline const TDbCol* TDbColSetIter::operator->() const

	{

	__ASSERT_DEBUG(iIndex<iArray->Count(),User::Invariant());

	return iColumn;

	}

/** Returns a column ordinal in the set for the currently referenced column definition.

@return The column ordinal of the current column definition. */

inline TDbColNo TDbColSetIter::Col() const

	{

	__ASSERT_DEBUG(iIndex<iArray->Count(),User::Invariant());

	return iIndex+1;

	}

/** Moves the iterator to the next column in the set post increment operator.

Note that this is implemented in terms of the pre-increment operator, and 

is less efficient.

@param Unused: required for the C++ compiler to resolve the ambiguity with 

the pre-increment operator.

@return A copy of this iterator, referring to the column definition before 

the increment operation is performed. */

inline TDbColSetIter TDbColSetIter::operator++(TInt)

	{

	TDbColSetIter tmp(*this);

	++(*this);

	return tmp;

	}

/**

TDbKeyCol copy constructor.

@param aSrcKeyCol This TDbKeyCol object will be constructed as an exact copy of aSrcKeyCol object.

*/

inline TDbKeyCol::TDbKeyCol(const TDbKeyCol& aSrcKeyCol) :

	iOrder(aSrcKeyCol.iOrder),

	iLength(aSrcKeyCol.iLength),

	iName(static_cast <const TDesC&> (aSrcKeyCol.iName))

	{

	}

/**

TDbKeyCol "=" operator.

@param aSrcKeyCol This TDbKeyCol object will be made to be an exact copy of aSrcKeyCol object.

*/

inline TDbKeyCol& TDbKeyCol::operator=(const TDbKeyCol& aSrcKeyCol)

	{

	iOrder = aSrcKeyCol.iOrder;

	iLength = aSrcKeyCol.iLength;

	iName = static_cast <const TDesC&> (aSrcKeyCol.iName);

	return *this;

	}

// Class CDbKey

inline TInt CDbKey::Count() const

	{

	return iKeys.Count();

	}

/** Returns a key column by its position in the key.

@param aCol The position of the column in the key. These are numbered from 

0 to Count()-1.

@return The key column requested. */

inline const TDbKeyCol& CDbKey::operator[](TInt aCol) const

	{

	return iKeys[aCol];

	}

/** Makes the key unique. This ensures that every key value in the index is distinct 

from every other. */

inline void CDbKey::MakeUnique()

	{

	iAttributes|=EUnique;

	}

/** Tests whether the key is unique.

@return ETrue, if the key is unique; EFalse, otherwise. */

inline TBool CDbKey::IsUnique() const

	{

	return iAttributes&EUnique;

	}

/** Tests whether the key is the primary key.

@return ETrue, if the key is unique; EFalse, otherwise. */

inline TBool CDbKey::IsPrimary() const

	{

	return iAttributes&EPrimary;

	}

/** Sets the way in which Text columns are compared for the key. All Text columns 

in the key are compared in the same way.

@param aComparison The comparison type to use. */

inline void CDbKey::SetComparison(TDbTextComparison aComparison)

	{

	iComparison=aComparison;

	}

/** Returns the method used to compare Text columns in this key.

@return The comparison type used for the key. */

inline TDbTextComparison CDbKey::Comparison() const

	{

	return iComparison;

	}

inline void CDbKey::MakePrimary()

	{

	iAttributes|=EPrimary;

	}

// Class TDbQuery

/** Constructs a query object from an SQL string and a text comparison mode.

Note that no copy is made of the descriptor passed; it is stored by reference 

in the query object.

@param aQuery The SQL string as a descriptor.

@param aComparison The type of text comparison to use in evaluation of the 

SQL. If not supplied, normal comparison is used. */

inline TDbQuery::TDbQuery(const TDesC& aQuery,TDbTextComparison aComparison):

	iQuery(aQuery), 

	iComparison(aComparison)

	{

	}

/** Returns the SQL string in the query object.

@return A descriptor containing the SQL string. */

inline const TDesC& TDbQuery::Query() const

	{

	return iQuery;

	}

/** Returns the text comparison mode for the query object.

@return The text comparison mode. */

inline TDbTextComparison TDbQuery::Comparison() const

	{

	return iComparison;

	}

// Class RDbHandleBase

inline RDbHandleBase::RDbHandleBase():

	iObject(0)

	{

	}

// Class RDbRowSet

/** Positions the cursor at the beginning of the rowset. 

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline void RDbRowSet::BeginningL()

	{

	GotoL(EBeginning);

	}

/** Positions the cursor at the end of the rowset. 

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline void RDbRowSet::EndL()

	{

	GotoL(EEnd);

	}

/** Positions the cursor on the first row in the rowset. If there are no rows, 

the cursor is positioned at the end.

@return ETrue if the cursor is now at a row, EFalse if it is at the end. 

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline TBool RDbRowSet::FirstL()

	{

	return GotoL(EFirst);

	}

/** Positions the cursor on the last row in the rowset. If there are no rows, the 

cursor is positioned at the beginning.

@return ETrue if the cursor is now at a row, EFalse if it is at the beginning. 

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline TBool RDbRowSet::LastL()

	{

	return GotoL(ELast);

	}

/** Moves the cursor to the next row in the rowset. If there are no more rows, 

the cursor is positioned to the end.

If the cursor is at the beginning prior to the function, it is equivalent 

to FirstL().

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline TBool RDbRowSet::NextL()

	{

	return GotoL(ENext);

	}

/** Moves the cursor to the previous row in the rowset. If there are no more rows, 

the cursor is positioned to the beginning.

If the cursor is at the end prior to the function, it is equivalent to LastL().

@return ETrue if the cursor is now at a row, EFalse if it is at the beginning. 

@capability Note For a secure shared database, the caller must satisfy the read

            access policy for the table.

*/

inline TBool RDbRowSet::PreviousL()

	{

	return GotoL(EPrevious);

	}

/** Tests whether a column has the NULL value.

Columns which have the NULL value can still be extracted with the correct 

accessor function, in which case numerical columns will return a 0 (or equivalent) 

value, and text and binary columns will have a zero length.

@param aCol The column ordinal for the column to test.

@return ETrue if column aCol is NULL, otherwise EFalse. */

inline TBool RDbRowSet::IsColNull(TDbColNo aCol) const

	{

	return ColSize(aCol)==0;

	}

/** Extracts a signed integer column value. The type should fit within a TInt.

@param aCol The column ordinal of the column to extract.

@return The value of column aCol. */

inline TInt RDbRowSet::ColInt(TDbColNo aCol) const

	{

	return ColInt32(aCol);

	}

/** Extracts an unsigned integer column value.

@param aCol The column ordinal of the column to extract.

@return The value of column aCol. */

inline TUint RDbRowSet::ColUint(TDbColNo aCol) const

	{

	return ColUint32(aCol);

	}

/** Extracts a TReal64 column value.

@param aCol The column ordinal of the column to extract.

@return The value of column aCol. */

inline TReal RDbRowSet::ColReal(TDbColNo aCol) const

	{

	return ColReal64(aCol);

	}

/** Sets a signed integer column value. The type should fit into a TInt.

@param aCol The column ordinal of the column to set.

@param aValue The new column value. */

inline void RDbRowSet::SetColL(TDbColNo aCol,TInt aValue)

	{

	SetColL(aCol, TInt32(aValue));

	}

/** Sets a signed integer column value. The type should fit into a TInt.

@param aCol The column ordinal of the column to set.

@param aValue The new column value. */

inline void RDbRowSet::SetColL(TDbColNo aCol,TUint aValue)

	{

	SetColL(aCol,TUint32(aValue));

	}

// Class TDbWindow

/** Constructs this object with a size of ENone. This can be used to request a 

view with no pre-evaluation window. */

inline TDbWindow::TDbWindow():

	iSize(ENone)

	{

	}

/** Constructs this object with a size of EUnlimited. This is used to request a 

completely pre-evaluated view. The constant KDbUnlimitedWindow is an instance 

of such a TDbWindow.

@param The argument is only used to direct the compiler to construct an unlimited 

window. */

inline TDbWindow::TDbWindow(TUnlimited):

	iSize(EUnlimited)

	{

	}

/** Returns the number of rows stored by the view.

@return The number of rows stored by the window. This could be one of the 

special values ENone or EUnlimited. */

inline TInt TDbWindow::Size() const

	{

	return iSize;

	}

/** Returns the preferred position in the window of the current row marker. i.e. 

the position with the forward and backward slots as requested.

@return The preferred position in the window. It is undefined if this is not 

a limited window. */

inline TInt TDbWindow::PreferredPos() const

	{

	return iPreferredPos;

	}

// Class TUnion

template <class T>

inline TUnion<T>::operator const T&() const

	{

	return *(const T*)&iRep[0];

	}

template <class T>

inline const T& TUnion<T>::operator()() const

	{

	return *(const T*)&iRep[0];

	}

template <class T>

inline T& TUnion<T>::operator()()

	{

	return *(T*)&iRep[0];

	}

template <class T>

inline void TUnion<T>::Set(const T& aT)

	{

	new(&iRep[0]) T(aT);

	}

// Class TDbLookupKey

inline TDbLookupKey::TDbLookupKey(): 

	iCount(0)

	{

	}

inline TInt TDbLookupKey::Count() const

	{

	return iCount;

	}

inline const TDbLookupKey::SColumn* TDbLookupKey::First() const

	{

	return &iKey[0];

	}

// Class TDbSeekKey

/** Constructs an empty key value. 

Add() should be called before the key value is used for lookup. */

inline TDbSeekKey::TDbSeekKey(): 

	iMaxKeys(1)

	{

	}

/** Constructs a key value for an TInt8, TInt16 or TInt32 column.

@param aKey The key value to lookup. */

inline TDbSeekKey::TDbSeekKey(TInt aKey): 

	iMaxKeys(1)

	{

	Add(aKey);

	}

/** Constructs a key value for a Bit, TUint8, TUint16 or TUint32 column.