/*
	Copyright (C) 2005-2006 Feeling Software Inc.
	MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
	This file was taken off the Protect project on 26-09-2005
*/

#ifndef _FUNCTOR_H_
#define _FUNCTOR_H_

// Functor with no argument.
template<typename ReturnType>
class IFunctor0
{
public:
	virtual ~IFunctor0() {}
	virtual ReturnType operator()() const = 0;
	virtual bool Compare(void* pObject, void* pFunction) const = 0;
};

template<typename Class, typename ReturnType>
class FUFunctor0 : public IFunctor0<ReturnType>
{
private:
	Class* m_pObject;
	ReturnType (Class::*m_pFunction) ();

public:
	FUFunctor0(Class* pObject, ReturnType (Class::*pFunction) ()) { m_pObject = pObject; m_pFunction = pFunction; }

	virtual ReturnType operator()() const
	{ return ((*m_pObject).*m_pFunction)(); }

	virtual bool Compare(void* pObject, void* pFunction) const
	{ return pObject == m_pObject && (size_t)pFunction == *(size_t*)&m_pFunction; }
};

template<typename ReturnType>
class FUStaticFunctor0 : public IFunctor0<ReturnType>
{
private:
	ReturnType (*m_pFunction) ();

public:
	FUStaticFunctor0(ReturnType (*pFunction) ()) { m_pFunction = pFunction; }

	virtual ReturnType operator()() const
	{ return (*m_pFunction)(); }

	virtual bool Compare(void*, void* pFunction) const
	{ return (size_t)pFunction == *(size_t*)&m_pFunction; }
};

// Functor with one argument.
template<typename Arg1, typename ReturnType>
class IFunctor1
{
public:
	virtual ~IFunctor1() {}
	virtual ReturnType operator()(Arg1 sArgument1) const = 0;
	virtual bool Compare(void* pObject, void* pFunction) const = 0;
};

template<typename Class, typename Arg1, typename ReturnType>
class FUFunctor1 : public IFunctor1<Arg1, ReturnType>
{
private:
	Class* m_pObject;
	ReturnType (Class::*m_pFunction) (Arg1);

public:
	FUFunctor1(Class* pObject, ReturnType (Class::*pFunction) (Arg1)) { m_pObject = pObject; m_pFunction = pFunction; }

	virtual ReturnType operator()(Arg1 sArgument1) const
	{ return ((*m_pObject).*m_pFunction)(sArgument1); }

	virtual bool Compare(void* pObject, void* pFunction) const
	{ return pObject == m_pObject && (size_t)pFunction == *(size_t*)&m_pFunction; }
};

template<typename Arg1, typename ReturnType>
class FUStaticFunctor1 : public IFunctor1<Arg1, ReturnType>
{
private:
	ReturnType (*m_pFunction) (Arg1);

public:
	FUStaticFunctor1(ReturnType (*pFunction) (Arg1)) { m_pFunction = pFunction; }

	virtual ReturnType operator()(Arg1 sArgument1) const
	{ return (*m_pFunction)(sArgument1); }

	virtual bool Compare(void*, void* pFunction) const
	{ return (size_t)pFunction == *(size_t*)&m_pFunction; }
};

// Functor with two argument.
template<typename Arg1, typename Arg2, typename ReturnType>
class IFunctor2
{
public:
	virtual ~IFunctor2() {}
	virtual ReturnType operator()(Arg1 sArgument1, Arg2 sArgument2) const = 0;
	virtual bool Compare(void* pObject, void* pFunction) const = 0;
};

template<typename Class, typename Arg1, typename Arg2, typename ReturnType>
class FUFunctor2 : public IFunctor2<Arg1, Arg2, ReturnType>
{
private:
	Class* m_pObject;
	ReturnType (Class::*m_pFunction) (Arg1, Arg2);

public:
	FUFunctor2(Class* pObject, ReturnType (Class::*pFunction) (Arg1, Arg2)) { m_pObject = pObject; m_pFunction = pFunction; }

	virtual ReturnType operator()(Arg1 sArgument1, Arg2 sArgument2) const
	{ return ((*m_pObject).*m_pFunction)(sArgument1, sArgument2); }

	virtual bool Compare(void* pObject, void* pFunction) const
	{ return pObject == m_pObject && (size_t)pFunction == *(size_t*)&m_pFunction; }
};

template<typename Arg1, typename Arg2, typename ReturnType>
class FUStaticFunctor2 : public IFunctor2<Arg1, Arg2, ReturnType>
{
private:
	ReturnType (*m_pFunction) (Arg1, Arg2);

public:
	FUStaticFunctor2(ReturnType (*pFunction) (Arg1, Arg2)) { m_pFunction = pFunction; }

	virtual ReturnType operator()(Arg1 sArgument1, Arg2 sArgument2) const
	{ return (*m_pFunction)(sArgument1, sArgument2); }

	virtual bool Compare(void*, void* pFunction) const
	{ return (size_t)pFunction == *(size_t*)&m_pFunction; }
};

// Macro for member function pointer type bypass
#define FUNCTOR_COMPARE(sFunctor, pObject, pFunction, bRet) \
{ \
	void* pVoid; \
	__asm { __asm push eax __asm mov eax, pFunction __asm mov pVoid, eax __asm pop eax } \
	bRet = sFunctor.Compare(pObject, pVoid); \
}

#endif //_FUNCTOR_H_