// Copyright (c) 2005-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:

//

#ifndef __IPCBUF_H__

#define __IPCBUF_H__

#include <s32buf.h>

#include "IpcDefs.h"

//Forward declarations

class TIpcArgs;

class RSqlDbSession;

/**

HIpcBuf class manages the "client to server" transfer of large data blocks.

It caches the data to be sent/retrieved on the client side and sychronises the content of the client-side cache

with the content of a similar server-side cache, sending appropriate read/write/sync commands to the server.

An instance of TIpcStreamBuf class is uased as a client-side cache.

The following code fragment shows how the class can be used to send to the server large blocks of data:

@code

//Step 1: Create the HIpcBuf instance.

HIpcBuf* ipcBuf = HIpcBuf::NewLC(params, function, args);

//Step 2: Create a stream instance. It will be used for sending the data to the server. All details about

//		  the data transfer will be performed by the ipcBuf object.

RWriteStream out(ipcBuf);

//Step 3: "TheObject" is some large data object which has to be sent to the server. Let's assume 

//		  "TheObject" has ExternalizeL() function which can be used to externalize the object into an output stream.

TheObject.ExternalizeL(out);

//Step 4: Commit the output stream. After the commit command the server will have all the data transferred.

out.CommitL();		

//Step 5: Cleanup.

CleanupStack::PopAndDestroy(ipcBuf);

@endcode

@see RSqlDbSession;

@see TIpcStreamBuf

@see RSessionBase

@internalComponent

*/

NONSHARABLE_CLASS(HIpcBuf) : public TStreamBuf

	{

public:

	static HIpcBuf* NewL(RSqlDbSession& aSession, TInt aFunction, TIpcArgs& aArgs);

	static HIpcBuf* NewLC(RSqlDbSession& aSession, TInt aFunction, TIpcArgs& aArgs);

	virtual ~HIpcBuf();

private:

	HIpcBuf(RSqlDbSession& aSession);

	void ConstructL(TInt aFunction, TIpcArgs& aArgs);

	// from TStreamBuf

	TInt UnderflowL(TInt aMaxLength);

	void OverflowL();

	void DoRelease();

	void DoSynchL();

	TInt DoReadL(TAny* aPtr, TInt aMaxLength);

	void DoWriteL(const TAny* aPtr, TInt aLength);

	TStreamPos DoSeekL(TMark aMark, TStreamLocation aLocation, TInt anOffset);

private:

	inline void SetPos(TRead, TInt aPos);

	inline void SetPos(TWrite, TInt aPos);

	inline TInt Pos(TRead) const;

	inline TInt Pos(TWrite) const;

	inline TInt MovePos(TRead, TInt aOffset);

	TInt IpcReadL(TAny* aPtr, TInt aMaxLength);

	void IpcWriteL(const TAny* aPtr, TInt aLength);

	TInt EndL();

	inline TInt Lag(TRead) const;

	inline TInt Lag(TWrite) const;

	inline TInt Mark(TRead) const;

	inline TInt Mark(TWrite) const;

private:

	RSqlDbSession& 	iSession;

	TInt			iHandle;

	TInt 			iRPos;

	TInt 			iWPos;

	TIpcStreamBuf	iBuf;

	};

#include "IPCBuf.inl"

#endif//__IPCBUF_H__