diff -r 000000000000 -r 7f656887cf89 libraries/clogger/inc/SensibleServer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libraries/clogger/inc/SensibleServer.h	Wed Jun 23 15:52:26 2010 +0100
@@ -0,0 +1,177 @@
+// SensibleServer.h
+// 
+// Copyright (c) 2006 - 2010 Accenture. All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the "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:
+// Accenture - Initial contribution
+//
+
+#ifndef SENSIBLESERVER_H
+#define SENSIBLESERVER_H
+
+#include <e32base.h>
+#include "cliserv.h"
+#include <f32file.h>
+#include <gdi.h>
+#include <basched.h>
+
+#include "SensibleCompat.h"
+
+class CCallbackContext;
+class CSensibleSession;
+class CFilteringScheduler;
+
+void PanicClient(const RMessage& aMessage, TInt TMyPanic);
+extern void CleanupPanicPushL();
+
+class CShutdown : public CTimer
+	{
+public:
+	inline CShutdown();
+	inline void ConstructL();
+	inline void Start(TInt aDelay);
+private:
+	void RunL();
+	};
+
+class CSensibleServer : public CServerBase
+	{
+public:
+	void AddSession();
+	void DropSession();
+	inline CFilteringScheduler* Scheduler();
+	CSensibleServer();
+	~CSensibleServer();
+	virtual void ConstructL();
+
+	// Some functions that call into the filtering scheduler
+	// NOTE: These functions cannot be used at the same time as queuing a callback that requires a result, nor can they be nested (you'll get a panic)
+	//void BlockAllAOsExceptServerRequests();
+	void BlockRequestsFrom(CActive* aActive1, CActive* aActive2=NULL);
+	void StopBlocking();
+
+protected:
+	#ifdef __HIDE_IPC_V1__
+	CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const;
+	#else
+	CSessionBase* NewSessionL(const TVersion& aVersion) const;
+	#endif
+	TInt RunError(TInt aError);
+	virtual TInt TransientServerShutdownTime() const; // Return 0 to never shutdown
+
+private:
+	TInt iSessionCount;
+	CShutdown iShutdown;
+	CFilteringScheduler* iScheduler;
+	CActiveScheduler* iOldScheduler;
+	};
+
+class CSensibleSession : public CSessionBase
+	{
+public:
+	CSensibleSession();
+	#ifndef __HIDE_IPC_V1__
+	void CreateL(const CServer& aServer);
+	#endif
+	void CreateL();
+	void QueueCallbackL(CCallbackContext* aContext); // This completes a callback immediately if possible, otherwise queues it. Used for callbacks that MUST be delivered.
+	TBool DispatchCallback(TServerCallback& aCallback); // This completes a callback immediately if possible, otherwise returns EFalse. Used for notify-style callbacks. The callback cannot have a context.
+	void CompleteNextCallback();
+
+protected:
+	virtual TBool DoServiceL(const RMessage& aMessage); // return EFalse if aMessage wasn't handled
+	~CSensibleSession();
+
+private:
+	inline CSensibleServer& Server();
+	void ServiceL(const RMessage& aMessage);
+//	inline TBool ReceivePending() const;
+private:
+	TSglQue<CCallbackContext> iCallbackQ;
+	RMessage iCallbackNotifier;
+	TBool iCallbackPending;
+	TBool iWaitingForCallbackResult;
+	};
+
+enum TCallbackContextFlags
+	{
+	EResultHBufC8 = 2,
+	EResultHBufC16 = 4,
+	EResultIsLeaveCode = 8,
+	EActive = 16,
+	EBlockServer = 32,
+	};
+
+class TCallbackWriter
+	{
+public:
+	TCallbackWriter(TServerCallback& aCallback, HBufC8** aContext);
+
+	// If any of the AddLs leave, they will delete aContext if it has been created
+	void AddL(TInt aInt);
+	void AddL(TUint aInt);
+	void AddL(TPoint aPoint);
+	void AddL(TSize aSize);
+	void AddL(TRgb aRgb);
+	void AddL(TRect aRect);
+	void AddL(const TDesC16& aDesc);
+	void AddL(const TDesC8& aDesc);
+
+private:
+	void AddL(const TDesC8& aData, char* aType);
+
+private:
+	TServerCallback& iCallback;
+	HBufC8** iContext;
+	TPtr8 iBuf;
+	TBool iInContext;
+	};
+
+class CCallbackContext : public CBase
+	{
+public:
+	union TResult
+		{
+		HBufC8** s;
+		HBufC16** l;
+		TDes8* pkg;
+		TInt integer;
+		};
+		
+public:
+	CCallbackContext(TCallbackCode aCode);
+	~CCallbackContext();
+	void SetFlags(TInt aFlags);
+	TBool Flag(TInt aFlags) const; // All bits of aFlags must be set to return true
+	void ClearFlags(TInt aFlags);
+	TBool CallbackRequiresResult() const;
+	TBool CallbackHasContext() const;
+	//void SetContext(HBufC8* aContext); // Takes ownership and clears flag EContextHBufC16
+	//void SetContext(HBufC16* aContext); // Takes ownership and sets flag EContextHBufC16
+	TCallbackWriter Writer();
+
+	void SetResult(TDes8& aPkg); // Sets appropriate flags
+	void SetResult(HBufC8*& aResult); // Sets appropriate flags
+	void SetResult(HBufC16*& aResult); // Sets appropriate flags
+	//void SetResult(TInt& aResult); // Sets appropriate flags
+	HBufC8* Context();
+	TResult& Result();
+	TServerCallback& Callback();
+	
+private:
+	void AddContext(const TUint8* aPtr, TInt aSize, char* aType);
+private:
+	TInt iFlags; // bitwise OR of TCallbackContextFlags
+	TServerCallback iCallback;
+	HBufC8* iContext;
+	TResult iResult;
+
+public:
+	TSglQueLink iLink;
+	};
+
+#endif