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

 //

 inline TInt DbsMessage(TInt aFunction,TInt aHandle)

 	{

 	return (aFunction<<KDbsHandleBits)|aHandle;

 	}

 inline TDbsFunction DbsFunction(TInt aMessage)

 	{

 	return TDbsFunction(aMessage>>KDbsHandleBits);

 	}

 inline TInt DbsHandle(TInt aMessage)

 	{

 	return aMessage&KDbsHandleMask;

 	}

 inline TDbsType DbsType(TInt aHandle)

 	{

 	return TDbsType(aHandle&KDbsTypeMask);

 	}

 inline TInt DbsMagic(TInt aHandle)

 	{

 	return (aHandle>>KDbsTypeBits)&KDbsMagicMask;

 	}

 inline TInt DbsObjectIndex(TInt aHandle)

 	{

 	return aHandle>>(KDbsTypeBits+KDbsMagicBits);

 	}

 inline TInt DbsMakeHandle(TInt aIndex,TInt aMagic,TDbsType aType)

 	{

 	return (((aIndex<<KDbsMagicBits)|aMagic)<<KDbsTypeBits)|aType;

 	}

 inline TInt DbsSessionHandle()

 	{

 	return DbsMakeHandle(1<<(KDbsIndexBits-1),0,EDbsSession);

 	}

 // streaming functions

 inline RWriteStream& operator<<(RWriteStream& aStream,const TDbCol& aCol)

 	{

 	ExternalizeL(aCol,aStream);

 	return aStream;

 	}

 inline RWriteStream& operator<<(RWriteStream& aStream,const CDbColSet& aColSet)

 	{

 	ExternalizeL(aColSet,aStream);

 	return aStream;

 	}

 inline RReadStream& operator>>(RReadStream& aStream,CDbColSet& aColSet)

 	{

 	InternalizeL(aColSet,aStream);

 	return aStream;

 	}

 inline RWriteStream& operator<<(RWriteStream& aStream,const CDbKey& aKey)

 	{

 	ExternalizeL(aKey,aStream);

 	return aStream;

 	}

 inline RReadStream& operator>>(RReadStream& aStream,CDbKey& aKey)

 	{

 	InternalizeL(aKey,aStream);

 	return aStream;

 	}

 inline RWriteStream& operator<<(RWriteStream& aStream,const CDbNames& aNames)

 	{

 	ExternalizeL(aNames,aStream);

 	return aStream;

 	}

 inline RReadStream& operator>>(RReadStream& aStream,CDbNames& aNames)

 	{

 	InternalizeL(aNames,aStream);

 	return aStream;

 	}

 /**

 This operator is used for externalizing CDbStrings array to a stream.

 @internalComponent

 */	

 inline RWriteStream& operator<<(RWriteStream& aStream,const CDbStrings& aStrings)

 	{

 	ExternalizeL(aStrings,aStream);

 	return aStream;

 	}

 /**

 This operator is used for internalizing CDbStrings array from a stream.

 @internalComponent

 */	

 inline RReadStream& operator>>(RReadStream& aStream,CDbStrings& aStrings)

 	{

 	InternalizeL(aStrings,aStream);

 	return aStream;

 	}

 template <class T>

 inline TExternalizeFunction Externalizer(const T*)

 	{

 	return TExternalizer<T>::Function();

 	}

 // Class TDbsParam

 inline void TDbsParam::operator=(const TDesC8& aDes)

 	{

 	iPtr=&aDes;

 	}

 inline void TDbsParam::operator=(const TDesC16& aDes)

 	{

 	iPtr=&aDes;

 	}

 inline void TDbsParam::operator=(TInt aVal)

 	{

 	iInt=aVal;

 	}

 // Class RDbsObject

 inline RDbsObject::RDbsObject():

 	iHandle(0)

 	{

 	}

 inline RDbsObject::RDbsObject(const RDbs& aDbs):

 	RDbs(aDbs),

 	iHandle(KDbsSessionHandle)

 	{

 	}

 inline TInt RDbsObject::Handle() const

 	{

 	return iHandle;

 	}

 inline void RDbsObject::OpenL(const RDbsObject& aDbs,TDbsFunction aFunction)

 	{

 	OpenL(aDbs,aFunction,0);

 	}

 inline void RDbsObject::OpenL(const RDbsObject& aDbs,TDbsFunction aFunction,const TIpcArgs& aArgs)

 	{

 	OpenL(aDbs,aFunction,&aArgs);

 	}

 inline void RDbsObject::OpenL(const RDbs& aDbs,TDbsFunction aFunction,const TIpcArgs& aArgs)

 	{

 	OpenL(RDbsObject(aDbs),aFunction,&aArgs);

 	}

 inline void RDbsObject::SendReceive(TDbsFunction aFunction,TRequestStatus& aStatus) const

 	{

 	SendReceive(aFunction,0,aStatus);

 	}

 inline TInt RDbsObject::SendReceive(TDbsFunction aFunction,const TIpcArgs& aArgs) const

 	{

 	return SendReceive(aFunction,&aArgs);

 	}

 inline TInt RDbsObject::SendReceiveL(TDbsFunction aFunction,const TIpcArgs& aArgs) const

 	{

 	return SendReceiveL(aFunction,&aArgs);

 	}

 inline void RDbsObject::SendReceive(TDbsFunction aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus) const

 	{

 	SendReceive(aFunction,&aArgs,aStatus);

 	}

 // Class CDbsDatabase

 inline CDbsDatabase::CDbsDatabase()

 	{

 	}

 // Class CDbsNotifier

 inline CDbsNotifier::CDbsNotifier()

 	{

 	}

 // Class CDbsIncrmental

 inline CDbsIncremental::CDbsIncremental()

 	{

 	}

 // Class CDbsConstraint

 inline CDbsConstraint::CDbsConstraint()

 	{

 	}

 // Class HDbsBuf

 inline HDbsBuf::HDbsBuf()

 	{

 	iBuf.iExt=-1;

 	}

 inline HDbsBuf::~HDbsBuf()

 	{

 	iIpc.Close();

 	}

 inline void HDbsBuf::SetPos(TRead,TInt aPos)

 	{

 	iRPos=aPos;

 	}

 inline void HDbsBuf::SetPos(TWrite,TInt aPos)

 	{

 	iWPos=aPos;

 	}

 inline TInt HDbsBuf::Pos(TRead) const

 	{

 	return iRPos;

 	}

 inline TInt HDbsBuf::Pos(TWrite) const

 	{

 	return iWPos;

 	}

 inline TInt HDbsBuf::MovePos(TRead,TInt anOffset)

 	{

 	return iRPos+=anOffset;

 	}

 inline TInt HDbsBuf::MovePos(TWrite,TInt anOffset)

 	{

 	return iWPos+=anOffset;

 	}

 inline TInt HDbsBuf::Lag(TRead) const

 	{

 	return Ptr(ERead)-End(ERead);

 	}

 inline TInt HDbsBuf::Lag(TWrite) const

 	{

 	return Ptr(EWrite)-iBuf.iData;

 	}

 inline TInt HDbsBuf::Mark(TRead) const

 	{

 	return Pos(ERead)+Lag(ERead);

 	}

 inline TInt HDbsBuf::Mark(TWrite) const

 	{

 	return Pos(EWrite)+Lag(EWrite);

 	}

 // Class CDbsSource

 inline TInt CDbsSource::LinkOffset()

 	{

 	return _FOFF(CDbsSource,iLink);

 	}

 inline CDbsSource::CDbsSource(const TDbFormat& aFormat):

 	iFormat(aFormat)

 	{

 	}

 inline void CDbsSource::Open()

 	{

 	++iConnections;

 	}

 inline CDbSource& CDbsSource::Source()

 	{

 	__ASSERT(iSource);

 	return *iSource;

 	}

 // Class CDbsDatabaseStub

 inline CDbsDatabaseStub::CDbsDatabaseStub()

 	{

 	}

 // Class CDbsConnection

 inline void CDbsConnection::Set(CDbsSource& aSource)

 	{

 	__ASSERT(!iSource);

 	iSource=&aSource;

 	aSource.Open();

 	}

 inline CDbsSource& CDbsConnection::Source() const

 	{

 	__ASSERT(iSource);

 	return *iSource;

 	}

 inline const CDbsConnection& CDbsConnection::Connection(const CDbObject& aObject)

 	{

 	__ASSERT(aObject.Context());

 	return *STATIC_CAST(const CDbsConnection*,aObject.Context());

 	}

 inline CDbsSource& CDbsConnection::Source(const CDbObject& aObject)

 	{

 	return Connection(aObject).Source();

 	}

 // Class RDbsSources

 inline RDbsSources::RDbsSources(RDbCache& aCache):

   	iSources(CDbsSource::LinkOffset()),

   	iDrivers(aCache)

   	{

   	}

 inline void RDbsSources::Close()

   	{

   	__ASSERT(iSources.IsEmpty());

   	iDrivers.Close();

   	}

 // Class CDbsServer

 inline TDes& CDbsServer::Name0()

 	{

 	return iName0;

 	}

 inline TDes& CDbsServer::Name1()

 	{

 	return iName1;

 	}

 inline TDes& CDbsServer::FileName()

 	{

 	return iFileName;

 	}

 inline RDbsSources& CDbsServer::Sources()

 	{

 	return iSources;

 	}

 inline RFs& CDbsServer::Fs()

 	{

 	return iFs;

 	}

 inline RDriveSpaceCol& CDbsServer::DriveSpaceCol()

 	{

 	return iDriveSpaceCol;

 	}

 inline void CDbsServer::Panic(const TDesC& aCategory,TInt aPanic)

 	{

 	Message().Panic(aCategory,aPanic);

 	}

 inline CPolicyProxy& CDbsServer::PolicyProxy() const

 	{

 	__ASSERT(iPolicyProxy);

 	return *iPolicyProxy;

 	}

 inline RDbPropsFactory& CDbsServer::DbPropsFactory()

 	{

 	return iDbPropsFactory;

 	}

 // Class CDbsSession::TEntry

 inline TDbsType CDbsSession::TEntry::Type() const

 	{

 	return TDbsType(iType);

 	}

 inline CDbsDatabaseStub& CDbsSession::TEntry::DatabaseStub()

 	{

 	__ASSERT(Type()==EDbsDatabase);

 	return *STATIC_CAST(CDbsDatabaseStub*,iObject);

 	}

 inline CDbDatabase& CDbsSession::TEntry::Database()

 	{

 	__ASSERT(Type()==EDbsDatabase);

 	return *STATIC_CAST(CDbDatabase*,iObject);

 	}

 inline CDbIncremental& CDbsSession::TEntry::Incremental()

 	{

 	__ASSERT(Type()==EDbsIncremental);

 	return *STATIC_CAST(CDbIncremental*,iObject);

 	}

 inline CDbCursor& CDbsSession::TEntry::Cursor()

 	{

 	__ASSERT(Type()==EDbsCursor);

 	return *STATIC_CAST(CDbCursor*,iObject);

 	}

 inline CDbRowConstraint& CDbsSession::TEntry::Constraint()

 	{

 	__ASSERT(Type()==EDbsConstraint);

 	return *STATIC_CAST(CDbRowConstraint*,iObject);

 	}

 inline HDbsStream& CDbsSession::TEntry::Stream()

 	{

 	__ASSERT(Type()==EDbsStream);

 	return *STATIC_CAST(HDbsStream*,iObject);

 	}

 inline CDbsObserver::HObserver& CDbsSession::TEntry::Observer()

 	{

 	__ASSERT(Type()==EDbsObserver);

 	return *STATIC_CAST(CDbsObserver::HObserver*,iObject);

 	}

 // Class CDbsSession

 inline TInt CDbsSession::Add(CDbIncremental* aIncremental, const MPolicy* aPolicy)

 	{

 	return DoAdd(aIncremental,EDbsIncremental, aPolicy);

 	}

 inline TInt CDbsSession::Add(CDbCursor* aCursor, const MPolicy* aPolicy)

 	{

 	return DoAdd(aCursor,EDbsCursor, aPolicy);

 	}

 inline TInt CDbsSession::Add(CDbRowConstraint* aConstraint, const MPolicy* aPolicy)

 	{

 	return DoAdd(aConstraint,EDbsConstraint, aPolicy);

 	}

 inline TInt CDbsSession::Add(HDbsStream* aStream, const MPolicy* aPolicy)

 	{

 	return DoAdd(aStream,EDbsStream, aPolicy);

 	}

 inline TInt CDbsSession::Add(CDbsObserver::HObserver* aObserver, const MPolicy* aPolicy)

 	{

 	return DoAdd(aObserver,EDbsObserver, aPolicy);

 	}

 inline CDbsServer& CDbsSession::Server() const

 	{

 	return *static_cast<CDbsServer*>(const_cast<CServer2*>(CSession2::Server()));

 	}

 inline RDbsSources& CDbsSession::Sources()

 	{

 	return Server().Sources();

 	}

 // Class HDbsStream

 inline HDbsStream::HDbsStream(MStreamBuf* aHost,TInt aReadPos):

 	iHost(*aHost),

 	iRPos(aReadPos),

 	iWPos(0)

 	{

 	__ASSERT(aHost);

 	}

 inline HDbsStream::~HDbsStream()

 	{

 	iHost.Release();

 	}

 inline TInt HDbsStream::SizeL()

 	{

 	return iHost.SizeL();

 	}

 inline void HDbsStream::SynchL()

 	{

 	iHost.SynchL();

 	}

 // Class HBufBuf

 inline HBufBuf::HBufBuf():

 	iBuf(0)

 	{

 	}

 inline HBufBuf::~HBufBuf()

 	{

 	delete iBuf;

 	}

 // Class CDbsSecureDatabase

 inline CDbsSecureDatabase::CDbsSecureDatabase()

 	{

 	}