class IFooBase
{
public:
	virtual void AddRef() = 0;
	virtual void Release() = 0;
	virtual IFooBase* QueryInterface(int32 id) const = 0;
};

class IFoo : public IFooBase
{
public:
	virtual int32 GetBar() = 0;
};

class IFooSession: public IFooBase
{
public:
	virtual int32 GetSessionID() = 0;
};

template <class IFace>
class IntfPtr
{
public:
	explicit  IntfPtr(IFace* p) 
		: fFace(p) {
		(void) static_cast<const IFooBase*>(p);
	}

	IntfPtr(const IFooBase* p, int32 id)
		:  fFace(QueryInterface_(p, id)) {}

	IFace* forget() {
		IFace* result = fFace;
		fFace = 0;
		return result;
	} 

	IFace * operator ->() const { return fFace; }

protected:
	static IFace* QueryInterface_(const IFooBase* p, int32 id) 
		{ return p ? static_cast<IFace*>(p->QueryInterface(id)) : nil; }

protected:
	IFace* fFace;
};

template <class IFace> 
class FooUtils
{
public:
	inline FooUtils() : fPtr(nil)
	{
		IntfPtr<IFace> utilsIntf(fSession, 0);
		fPtr = utilsIntf.forget();
	};

	inline IFace* operator ->() const { return static_cast<IFace*>(fPtr); }

protected:
	IFooBase* fPtr;
	IFooSession* fSession;
};

template <class Interface>
class CFooBase : public Interface
{
public:
	inline CFooBase(IFooBase* base)
		: fPtr(base)
	{}

	inline void AddRef() {}
	inline void Release() {}

protected:
	IFooBase* fPtr;
};

class CFoo : CFooBase<IFoo>
{
public:
	CFoo(IFooBase* base) : CFooBase<IFoo>(base) {}

	int32 GetBar() { return 32; }
};

class CTest
{
public:
	CTest() {
		FooUtils<IFoo> foo;
		foo->

	}
};