--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/pcdbms/utable/UT_STD.INL	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,206 @@
+// 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;}