source: NonGTP/FCollada/FUtils/FUFunctor.h @ 964

/*
        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_