#ifndef _ImplementQI_h_included
#define _ImplementQI_h_included
#if _MSC_VER > 1000
template<typename T>
struct InterfaceIID
{
	static const IID &iid() { return __uuidof(T); }
};
#ifndef ATL_NO_VTABLE
#ifdef _ATL_DISABLE_NO_VTABLE
#define ATL_NO_VTABLE
#else
#define ATL_NO_VTABLE __declspec(novtable)
#endif
#endif // ifndef ATL_NO_VTABLE
#else
template<typename T>
struct InterfaceIID
{
	static const IID &iid();
};
#ifndef ATL_NO_VTABLE
#define ATL_NO_VTABLE
#endif // ifndef ATL_NO_VTABLE
#endif

template<typename T>
struct InterfaceBase
{
	typedef IUnknown Type;
};

template<typename Interface>
struct IIDFinder
{
	static bool HasIID(REFIID riid)
	{
		if(riid == InterfaceIID<Interface>::iid())
			return true;
		return IIDFinder<InterfaceBase<Interface>::Type>::HasIID(riid);
	}
};

// Specialisation for IUnknown to terminate the recursive template above

template<>
struct IIDFinder<IUnknown>
{
	static bool HasIID(REFIID riid)
	{
		return false;
	}
};
// Within this namespace are templates you probably
// aren't interested in.
namespace _ImplementQIImplementation {
	struct Dummy
	{
	};	
	
	template<typename T>
		struct ATL_NO_VTABLE Interface1 : public T
	{
		void *SupportsInterface(REFIID riid)
		{
			if(IIDFinder<T>::HasIID(riid))
				return static_cast<T *>(this);
			return 0;
		}
	};
	
	struct ATL_NO_VTABLE Interface1<Dummy>
	{
		void *SupportsInterface(REFIID) { return 0; }
	};
	
	template<typename LeftInterface, typename _right>
		struct ATL_NO_VTABLE splitter : public Interface1<LeftInterface>, _right
	{
		void *SupportsInterface(REFIID riid)
		{
			void *retval = Interface1<LeftInterface>::SupportsInterface(riid);
			return retval ? retval : _right::SupportsInterface(riid);
		}
	};


	template<typename I1, typename I2>
		struct ATL_NO_VTABLE Interface2 : public splitter<I1, Interface1<I2> >
	{
	};
	
	struct ATL_NO_VTABLE Interface2<Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3>
		struct ATL_NO_VTABLE Interface3 : public splitter<I1, Interface2<I2, I3> >
	{
	};
	
	struct ATL_NO_VTABLE Interface3<Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3, typename I4>
		struct ATL_NO_VTABLE Interface4 : public splitter<I1, Interface3<I2, I3, I4> >
	{
	};
	
	struct ATL_NO_VTABLE Interface4<Dummy, Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3, typename I4, typename I5>
		struct ATL_NO_VTABLE Interface5 : public splitter<I1, Interface4<I2, I3, I4, I5> >
	{
	};
	
	struct ATL_NO_VTABLE Interface5<Dummy, Dummy, Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3, typename I4, typename I5, typename I6>
		struct ATL_NO_VTABLE Interface6 : public splitter<I1, Interface5<I2, I3, I4, I5, I6> >
	{
	};
	
	struct ATL_NO_VTABLE Interface6<Dummy, Dummy, Dummy, Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3, typename I4, typename I5, typename I6, typename I7>
		struct ATL_NO_VTABLE Interface7 : public splitter<I1, Interface6<I2, I3, I4, I5, I6, I7> >
	{
	};
	
	struct ATL_NO_VTABLE Interface7<Dummy, Dummy, Dummy, Dummy, Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
	
	template<typename I1, typename I2, typename I3, typename I4, typename I5, typename I6, typename I7, typename I8>
		struct ATL_NO_VTABLE Interface8 : public splitter<I1, Interface7<I2, I3, I4, I5, I6, I7, I8> >
	{
	};
	
	struct ATL_NO_VTABLE Interface8<Dummy, Dummy, Dummy, Dummy, Dummy, Dummy, Dummy, Dummy> : public Interface1<Dummy>
	{
	};
} // namespace _ImplementQIImplementation

template<typename I1 = _ImplementQIImplementation::Dummy,
			typename I2 = _ImplementQIImplementation::Dummy,
			typename I3 = _ImplementQIImplementation::Dummy,
			typename I4 = _ImplementQIImplementation::Dummy,
			typename I5 = _ImplementQIImplementation::Dummy,
			typename I6 = _ImplementQIImplementation::Dummy,
			typename I7 = _ImplementQIImplementation::Dummy,
			typename I8 = _ImplementQIImplementation::Dummy>
			class ATL_NO_VTABLE ImplementQI : public _ImplementQIImplementation::Interface8<I1, I2, I3, I4, I5, I6, I7, I8>
{
	public:
	STDMETHOD(QueryInterface)(REFIID riid, void **ppv)
	{
		using _ImplementQIImplementation::Interface8;
		*ppv = Interface8<I1, I2, I3, I4, I5, I6, I7, I8>::SupportsInterface(riid);
		if(!*ppv && riid == InterfaceIID<IUnknown>::iid())
			*ppv = this;
		if(*ppv)
		{
			static_cast<IUnknown *>(*ppv)->AddRef();
			return S_OK;
		}
		else
			return E_NOINTERFACE;
	}
	template <class Interface>
	HRESULT QueryInterface(Interface** pp)
	{
		return QueryInterface(InterfaceIID<Interface>::iid(),
			reinterpret_cast<void**>(pp));
	}
};

// class CClass : public ImplementQI<Interface1, Interface2>
// {
//	  // Implement everything, including AddRef() and Release(), except for QueryInterface()
// };


// Two macros to make explicit how you declare that one interface is a base of another:


// DECLARE_BASE
// Specify that Interface is derived from DerivedFrom
// as in
// interface IInterface : IDerivedFrom
//
// For example, if I had the following IDL
//
// interface IPrinter : IDevice
// {
// };

// Then you should have in the header files:
//
// DECLARE_BASE(IPrinter, IDevice)
//
// If you forget to declare the base, then
// QueryInterface for the base interface will return E_NOINTERFACE.
// By default interfaces are derived from IUnknown
// so you don't need to specify this.

#define DECLARE_BASE(__xyzqInterface, __xyzqDerivedFrom)\
	template<>\
	struct InterfaceBase<__xyzqInterface>\
	{\
		typedef __xyzqDerivedFrom Type;\
	};

// DECLARE_IID
// Associate an IID with an interface.
// Defaults to __xyzquuidof()
// You generally don't need to use this
// macro if you use MIDL or #import
// to get the interface.
//
// But if you don't like declspec(uuid())
// then you can use it like so:
// DECLARE_IID(IPrinter, IID_IPrinter)

#define DECLARE_IID(__xyzqInterface, __xyzqinterfaceIID)\
	template<>\
	struct InterfaceIID<__xyzqInterface>\
	{\
		static const IID &iid() { return __xyzqinterfaceIID; }\
	};

template<class T, class ThreadModelT>
class ATL_NO_VTABLE HeapObject : public T
{
private:
	LONG m_dwRef;
protected:
	HeapObject() : m_dwRef(0) {}
	// Ensure destructor is virtual
	virtual ~HeapObject() {}
public:
	STDMETHOD_(ULONG, AddRef)()
	{
		return ThreadModelT::Increment(&m_dwRef);
	}
	STDMETHOD_(ULONG, Release)()
	{
		LONG retval = ThreadModelT::Decrement(&m_dwRef);
		if(retval == 0)
			delete this;
		return retval;
	}

};

// struct containing classes that might vary their implementation
// depending on threading model.
struct MultiThreaded
{
	// Mixin class that
	// adds Heap lifetime semantics. When created with new,
	// the object has 0 references.
	// When the reference count drops down to zero again,
	// the object deletes itself.

	template<typename T>
		class ATL_NO_VTABLE HeapCounter : public HeapObject<T, MultiThreaded>
	{
	};

	inline static LONG Increment(LONG *pLong)
	{
		return ::InterlockedIncrement(pLong);
	}
	inline static LONG Decrement(LONG *pLong)
	{
		return ::InterlockedDecrement(pLong);
	}
};

struct SingleThreaded
{
	template<typename T>
	class ATL_NO_VTABLE HeapCounter : public HeapObject<T, SingleThreaded>
	{
	};

	inline static LONG Increment(LONG *pLong)
	{
		return ++(*pLong);
	}
	inline static LONG Decrement(LONG *pLong)
	{
		return --(*pLong);
	}
};

template<typename T>
struct ATL_NO_VTABLE StaticCounter : public T
{
	STDMETHOD_(ULONG, AddRef)() { return 2; }
	STDMETHOD_(ULONG, Release)() { return 1; }
};

// 06-July-2000 SimpleHeapObject1 is no longer any more efficient
// than the general implementation. It is merely preserved here for
// backward compatibility. You'll make the code more "general" by simply
// using
// HeapObject<ImplementQI<IInterface>, ThreadModel>
// or
// ThreadModel::HeapCounter<ImplementQI<IInterface> >
// Same applies for SimpleHeapObject2. There will never be
// a SimpleHeapObject3.
template<typename InterfaceT,
				typename ThreadModelT = DefaultThreadModelT>
				struct ATL_NO_VTABLE SimpleHeapObject1 : public HeapObject<ImplementQI<InterfaceT>, ThreadModelT>
{
};

template<typename InterfaceT, typename Interface2T,
				typename ThreadModelT = DefaultThreadModelT>
				struct ATL_NO_VTABLE SimpleHeapObject2 : public HeapObject<ImplementQI<InterfaceT, Interface2T>, ThreadModelT>
{
};

#endif // ImplementQI