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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include "D32Assert.h"

// Class RDbIndexes

inline RDbIndexes::RDbIndexes()

	: iRep(_FOFF(CDbTableIndexDef,iLink))

	{}

// Class HDbColumnSet

inline HDbColumnSet::TIterator HDbColumnSet::ColumnL(const TDesC& aColumn)

	{return CONST_CAST(TIterator,((const HDbColumnSet*)this)->ColumnL(aColumn));}

// Class RDbTableSchema

inline RDbTableSchema::RDbTableSchema()

	: iRep(_FOFF(CDbTableDef,iLink))

	{}

inline void RDbTableSchema::Close()

	{Discard();}

inline TBool RDbTableSchema::IsLoaded() const

	{return iLoaded;}

inline void RDbTableSchema::Remove(CDbTableDef* aDef)

	{iRep.Remove(*aDef);}

// Class CDbTable

inline void CDbTable::Discard()

	{__ASSERT(iRef==ECached);Release();}

inline TBool CDbTable::IsIdle() const

	{return iRef==EIdle;}

inline TBool CDbTable::InUse() const

	{return iRef>=0;}

inline RDbCache& CDbTable::Cache()

	{return Database().iCache;}

// Class CDbTable::TValid

inline CDbTable& CDbTable::TValid::Table() const

	{return iTable;}

inline CDbTable::TValid::operator TAny*() const

	{return Table().iDatabase;}

inline RDbTransaction& CDbTable::TValid::Transaction() const

	{return Table().Database().Transaction();}

// Class RDbTables

inline RDbTables::RDbTables()

	: iRep(_FOFF(CDbTable,iLink))

	{}

inline TBool RDbTables::IsEmpty() const

	{return iRep.IsEmpty();}

inline void RDbTables::Add(CDbTable& aTable)

	{iRep.AddLast(aTable);}

inline void RDbTables::Remove(CDbTable& aTable)

	{iRep.Remove(aTable);}

inline RDbTables::operator TSglQueBase&()

	{return iRep;}

// Class RDbTransaction

inline RDbTransaction::RDbTransaction()

	:iMaxLock(1)

	{

	__ASSERT(iDatabase==0);

	__ASSERT(iAction==EDbReadLock);

	__ASSERT(iLockState==EDbReadLock);

	__ASSERT(iSharers==0);

	__ASSERT(iLockCount==0);

	__ASSERT(iUpdaters==0);

	__ASSERT(iNotifier==0);

	}

inline void RDbTransaction::Open(CDbTableDatabase& aDatabase)

	{__ASSERT(!iDatabase);iDatabase=&aDatabase;}

inline const TDbGeneration& RDbTransaction::RollbackGeneration() const

	{return iRollback;}

inline TBool RDbTransaction::IsLocked() const

	{return iLockCount>0;}

inline CDbTableDatabase& RDbTransaction::Database()

	{__ASSERT(iDatabase);return *iDatabase;}

inline void RDbTransaction::ReadyL() const

	{if (iLockState&EFailed) __LEAVE(KErrDied);}

// Class CDbTableDatabase

inline void CDbTableDatabase::Open()

	{++iRef;}

inline void CDbTableDatabase::AddTable(CDbTable& aTable)

	{iTables.Add(aTable);}

// Class CDbTableSource

inline void CDbTableSource::SetIterator(CDbRecordIter* anIter)

	{iIter=anIter;}

inline CDbTable& CDbTableSource::Table()

	{return iRow.Table();}

inline const RDbTableRow& CDbTableSource::Row()

	{return iRow;}

// Class CDbDataStage

inline void CDbDataStage::SetSource(CDbDataSource* aSource)

	{__ASSERT(!iSource);iSource=aSource;}

inline CDbDataSource& CDbDataStage::Source()

	{return *iSource;}

inline const CDbDataSource& CDbDataStage::Source() const

	{return *iSource;}

// Class CDbRestrictStage

inline void CDbRestrictStage::SetRestriction(CSqlSearchCondition* aRestriction)

	{__ASSERT(!iRestriction);iRestriction=aRestriction;}

inline CSqlSearchCondition& CDbRestrictStage::Restriction() const

	{__ASSERT(iRestriction);return *iRestriction;}

// Class RDbAccessPlan

inline RDbAccessPlan::RDbAccessPlan(CSqlQuery* aQuery,TDbTextComparison aComparison)

	:iPlans(EGranularity),iComparison(aComparison),iQuery(aQuery)

	{__DEBUG(iSource=NULL;iTable=NULL;)}

inline RDbAccessPlan::RDbAccessPlan()

	:iPlans(EGranularity),iComparison(EDbCompareNormal)

	{__DEBUG(iSource=NULL;iTable=NULL;)}

inline CDbTable& RDbAccessPlan::Table()

	{__ASSERT(iTable);return *iTable;}

inline CDbDataSource& RDbAccessPlan::Source()

	{__ASSERT(iSource);return *iSource;}

inline CDbDataSource* RDbAccessPlan::Adopt()

	{__ASSERT(iSource);CDbDataSource* s=iSource;iSource=NULL;return s;}

// Class RDbAccessPlan::TPlan

inline RDbAccessPlan::TPlan::TPlan()

	:iFlags(0),iLower(0),iUpper(0)

	{}

inline TBool RDbAccessPlan::TPlan::operator!=(const TPlan& aPlan) const

	{return !(iFlags==aPlan.iFlags && iIndex==aPlan.iIndex && iUpper==aPlan.iUpper && iLower==aPlan.iLower);}

// Class RDbAccessPlan::CDbCompPredicateList

inline RDbAccessPlan::CDbCompPredicateList::CDbCompPredicateList(const CDbTableDef& aTableDef,TDbTextComparison aComparison)

	: CArrayFixFlat<CSqlCompPredicate*>(EGranularity),iTableDef(aTableDef),iComparison(aComparison),iRestriction(EFalse)

	{}

inline TBool RDbAccessPlan::CDbCompPredicateList::IsRestriction()

	{return iRestriction;}

// Class CDbTableCursor

inline CDbBlobSpace& CDbTableCursor::BlobsL() const

	{CDbBlobSpace* b=iValid.Table().BlobsL();__ASSERT(b);return *b;}

inline void CDbTableCursor::AddSink()

	{__ASSERT((iFlags&EWriteBuf)==0);iFlags|=EWriteBuf;}

inline void CDbTableCursor::ReleaseSink()

	{__ASSERT(iFlags&EWriteBuf);iFlags&=~EWriteBuf;}

inline void CDbTableCursor::AddSource()

	{__ASSERT(iReadBuf<EMaxReadBuf);++iReadBuf;}

inline void CDbTableCursor::ReleaseSource()

	{__ASSERT(iReadBuf>0);--iReadBuf;}

// Class CDbTableCursor::HReadBuf

inline void CDbTableCursor::HReadBuf::Set(MStreamBuf* aHost)

	{__ASSERT(!iHost);iHost=aHost;}

// Class CDbTableDatabase::CIncremental

inline RDbTransaction& CDbTableDatabase::CIncremental::Transaction()

	{return iTransaction;}

inline CDbTableDatabase& CDbTableDatabase::CIncremental::Database()

	{return Transaction().Database();}

inline void CDbTableDatabase::CIncremental::Construct(CStepper* aStepper)

	{iStepper=aStepper;}

inline TBool CDbTableDatabase::CIncremental::IsCommitted() const

	{return iState==ECommitted;}

// Class CDbTableDatabase::CCreateIndex

inline CDbTableDatabase::CCreateIndex::CCreateIndex(RDbTransaction& aTransaction)

	: CIncrementalDDL(aTransaction)

	{}

// Class CDbTableDatabase::CDropIndex

inline CDbTableDatabase::CDropIndex::CDropIndex(RDbTransaction& aTransaction)

	: CIncrementalDDL(aTransaction)

	{}

// Class CDbTableDatabase::CDropTable

inline CDbTableDatabase::CDropTable::CDropTable(RDbTransaction& aTransaction)

	: CIncrementalDDL(aTransaction)

	{}

// Class CDbTableDatabase::CAlterTable

inline CDbTableDatabase::CAlterTable::CAlterTable(RDbTransaction& aTransaction,CDbTableDef& aDef)

	: CIncrementalDDL(aTransaction), iDef(aDef)

	{}

// Class CDbIncrementalDML

inline CDbIncrementalDML::CDbIncrementalDML(RDbAccessPlan& aPlan)

	:iTable(aPlan.Table()),iSource(aPlan.Adopt())

	{__ASSERT(iState==EInitialising);}

inline RDbTransaction& CDbIncrementalDML::Transaction()

	{return iTable.Database().Transaction();}

inline TBool CDbIncrementalDML::IsUpdate() const

	{return iValues!=NULL;}

inline void CDbIncrementalDML::SetState(TState aState)

	{iState=aState;}

// Class CDbTableDatabase::CInterface

inline CDbTableDatabase& CDbTableDatabase::CInterface::Database()

	{return iDatabase;}

// Class CDbTableDatabase::CSource

inline CDbTableDatabase& CDbTableDatabase::CSource::Database()

	{return iDatabase;}