// 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()
	{
	}