delegate_decl.h

Go to the documentation of this file.

 
#ifndef A_UTIL_UTIL_DELEGATE_DECL_HEADER_INCLUDED
#define A_UTIL_UTIL_DELEGATE_DECL_HEADER_INCLUDED
 
namespace a_util {
namespace detail {
namespace delegates {
template <typename ReturnType>
class DelegateInterface {
public:
    virtual ~DelegateInterface();
    virtual ReturnType invoke() = 0;
    virtual DelegateInterface<ReturnType>* clone() = 0;
};
 
template <typename ReturnType>
class FunctionDelegate : public DelegateInterface<ReturnType> {
    typedef ReturnType (*Function)();
 
public:
    FunctionDelegate(Function f);
    virtual ReturnType invoke();
    virtual DelegateInterface<ReturnType>* clone();
 
private:
    Function _func;
};
 
template <typename ReturnType, typename Method, typename Instance>
class MethodDelegate : public DelegateInterface<ReturnType> {
public:
    MethodDelegate(Method method, Instance& instance);
    virtual ReturnType invoke();
    virtual DelegateInterface<ReturnType>* clone();
 
private:
    Method _method;
    Instance& _instance;
};
} // namespace delegates

namespace functions {
template <typename ReturnType, typename ParamType>
class DelegateInterface {
public:
    virtual ~DelegateInterface();
    virtual ReturnType invoke(ParamType) = 0;
    virtual DelegateInterface<ReturnType, ParamType>* clone() = 0;
};
 
template <typename ReturnType, typename ParamType>
class FunctionDelegate : public DelegateInterface<ReturnType, ParamType> {
    typedef ReturnType (*Function)(ParamType);
 
public:
    FunctionDelegate(Function f);
    virtual ReturnType invoke(ParamType param);
    virtual DelegateInterface<ReturnType, ParamType>* clone();
 
private:
    Function _func;
};
 
template <typename ReturnType, typename ParamType, typename Method, typename Instance>
class MethodDelegate : public DelegateInterface<ReturnType, ParamType> {
public:
    MethodDelegate(Method method, Instance& inst);
    virtual ReturnType invoke(ParamType param);
    virtual DelegateInterface<ReturnType, ParamType>* clone();
 
private:
    Method _method;
    Instance& _instance;
};
 
} // namespace functions

template <typename DelegateType>
class DelegateBase {
protected: // construction/destruction only available through specialized class
    ~DelegateBase();
    DelegateBase();
    DelegateBase(const DelegateBase& other);
    DelegateBase& operator=(const DelegateBase& other);
 
    void setDelegate(DelegateType* delegate);
    DelegateType* getDelegate();
    const DelegateType* getDelegate() const;
 
public:
    operator bool() const;
 
private:
    DelegateType* _ptr_to_callee;
};
 
} // namespace detail
 
namespace experimental {
template <typename ReturnType>
class NullaryDelegate
    : public detail::DelegateBase<detail::delegates::DelegateInterface<ReturnType>> {
public:
    NullaryDelegate(ReturnType (*Function)());
    template <typename Method, typename Instance>
    NullaryDelegate(Method method, Instance& instance);

    ReturnType operator()();
 
private:
    typedef detail::DelegateBase<detail::delegates::DelegateInterface<ReturnType>> Base;
};

template <typename ReturnType, typename ParamType>
class UnaryDelegate
    : public detail::DelegateBase<detail::functions::DelegateInterface<ReturnType, ParamType>> {
public:
    UnaryDelegate(ReturnType (*Function)(ParamType));

    template <typename Method, typename Instance>
    UnaryDelegate(Method method, Instance& instance);

    ReturnType operator()(ParamType param);
 
private:
    typedef detail::DelegateBase<detail::functions::DelegateInterface<ReturnType, ParamType>> Base;
};
 //
 
} // namespace experimental
} // namespace a_util

#include <a_util/base/detail/delegate_impl.h>
 
#endif // A_UTIL_UTIL_DELEGATE_DECL_HEADER_INCLUDED