Pastebin: function.h

Format

C++

Post date

2016-02-14 19:54

Période de publication

Illimité

 
 #pragma once
 
 #include <algorithm>
 #include <stdexcept>
 
 class FunctionCallException : public std::logic_error
 {
 public:
     FunctionCallException() : logic_error("FunctionCallException")
     {
     }
 };
 
 template<typename T>
 class Function;
 
 #define DEFINE_FUNC  \
 template<typename TRet TYPENAMES_DECL_C TYPENAMES_DECL> \
 class Function<TRet(TYPES)> \
 { \
     class ICallable \
     { \
     public: \
         virtual ~ICallable() \
         { \
         } \
          \
         virtual TRet operator()(ARGS_DECL) const = 0; \
         virtual ICallable* Clone() const = 0; \
     }; \
      \
     template<typename TObject> \
     class CallableImpl : public ICallable \
     { \
     public: \
         explicit CallableImpl(TObject obj) : m_Object(obj) \
         { \
         } \
          \
         virtual TRet operator()(ARGS_DECL) const \
         { \
             return m_Object(ARGS); \
         } \
          \
         virtual ICallable* Clone() const \
         { \
             return new CallableImpl<TObject>(m_Object); \
         } \
          \
     private: \
         TObject m_Object; \
     }; \
      \
 public: \
     Function() : m_pCallable(NULL) \
     { \
     } \
      \
     template<typename TObject> \
     Function(TObject obj) : m_pCallable(new CallableImpl<TObject>(obj)) \
     { \
     } \
      \
     Function(const Function& rhs) : m_pCallable(rhs.m_pCallable ? rhs.m_pCallable->Clone() : NULL) \
     { \
     } \
      \
     Function& operator=(const Function& rhs) \
     { \
         Function(rhs).Swap(*this); \
         return *this; \
     } \
      \
     void Swap(Function& rhs) \
     { \
         using std::swap; \
         swap(m_pCallable, rhs.m_pCallable); \
     } \
      \
     TRet operator()(ARGS_DECL) const \
     { \
         if (!m_pCallable) \
         { \
             throw FunctionCallException(); \
         } \
          \
         return (*m_pCallable)(ARGS); \
     } \
      \
 private: \
     ICallable* m_pCallable; \
 }; \
  \
 template<TYPENAMES_DECL> \
 class Function<void(TYPES)> \
 { \
     class ICallable \
     { \
     public: \
         virtual ~ICallable() \
         { \
         } \
          \
         virtual void operator()(ARGS_DECL) const = 0; \
         virtual ICallable* Clone() const = 0; \
     }; \
      \
     template<typename TObject> \
     class CallableImpl : public ICallable \
     { \
     public: \
         explicit CallableImpl(TObject obj) : m_Object(obj) \
         { \
         } \
          \
         virtual void operator()(ARGS_DECL) const \
         { \
             m_Object(ARGS); \
         } \
          \
         virtual ICallable* Clone() const \
         { \
             return new CallableImpl<TObject>(m_Object); \
         } \
          \
     private: \
         TObject m_Object; \
     }; \
      \
 public: \
     Function() : m_pCallable(NULL) \
     { \
     } \
      \
     template<typename TObject> \
     Function(TObject obj) : m_pCallable(new CallableImpl<TObject>(obj)) \
     { \
     } \
      \
     Function(const Function& rhs) : m_pCallable(rhs.m_pCallable ? rhs.m_pCallable->Clone() : NULL) \
     { \
     } \
      \
     Function& operator=(const Function& rhs) \
     { \
         Function(rhs).Swap(*this); \
         return *this; \
     } \
      \
     void Swap(Function& rhs) \
     { \
         using std::swap; \
         swap(m_pCallable, rhs.m_pCallable); \
     } \
      \
     void operator()(ARGS_DECL) const \
     { \
         if (!m_pCallable) \
         { \
             throw FunctionCallException(); \
         } \
          \
         (*m_pCallable)(ARGS); \
     } \
      \
 private: \
     ICallable* m_pCallable; \
 };
 
 
 // 0
 
 #define TYPENAMES_DECL_C
 #define TYPENAMES_DECL
 #define TYPES
 #define ARGS_DECL
 #define ARGS
 
 DEFINE_FUNC
 
 #undef TYPENAMES_DECL_C
 #undef TYPENAMES_DECL
 #undef TYPES
 #undef ARGS_DECL
 #undef ARGS
 
 // ---
 
 #define TYPENAMES_DECL_C   , 
 
 // 1
 
 #define TYPENAMES_DECL     typename TArg1
 #define TYPES              TArg1
 #define ARGS_DECL          TArg1 arg1
 #define ARGS               arg1
 
 DEFINE_FUNC
 
 #undef TYPENAMES_DECL
 #undef TYPES
 #undef ARGS_DECL
 #undef ARGS
 
 
 // 2
 
 #define TYPENAMES_DECL     typename TArg1, typename TArg2
 #define TYPES              TArg1, TArg2
 #define ARGS_DECL          TArg1 arg1, TArg2 arg2
 #define ARGS               arg1, arg2
 
 DEFINE_FUNC
 
 #undef TYPENAMES_DECL
 #undef TYPES
 #undef ARGS_DECL
 #undef ARGS
 
 // 3
 
 #define TYPENAMES_DECL     typename TArg1, typename TArg2, typename TArg3
 #define TYPES              TArg1, TArg2, TArg3
 #define ARGS_DECL          TArg1 arg1, TArg2 arg2, TArg3 arg3
 #define ARGS               arg1, arg2, arg3
 
 DEFINE_FUNC
 
 #undef TYPENAMES_DECL
 #undef TYPES
 #undef ARGS_DECL
 #undef ARGS
 
 // 4
 
 #define TYPENAMES_DECL     typename TArg1, typename TArg2, typename TArg3, typename TArg4
 #define TYPES              TArg1, TArg2, TArg3, TArg4
 #define ARGS_DECL          TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4
 #define ARGS               arg1, arg2, arg3, arg4
 
 DEFINE_FUNC
 
 #undef TYPENAMES_DECL
 #undef TYPES
 #undef ARGS_DECL
 #undef ARGS
 
 // ---
 
 #undef TYPENAMES_DECL_C
 
 template<typename T>
 void swap(Function<T>& lhs, Function<T>& rhs)
 {
     lhs.Swap(rhs);
 }