Method.h

#pragma once
 
#include <cassert>
 
#include "Name.h"
 
#ifdef _WIN32
// Turn off VS optimization of member pointers.
#pragma pointers_to_members(full_generality, single_inheritance)
#endif
 
namespace Cogs
{
  namespace Reflection
  {
    struct ReflectedTarget
    {
      // No members needed.
    };
 
    constexpr size_t kMaxMethodArguments = 4;
 
    class COGSFOUNDATION_API Method
    {
    public:
      typedef void (ReflectedTarget::*MemberFunction)();
 
      template<typename Class, typename Ret, typename... Args>
      Method(const Name& name, Ret (Class::*method)(Args...)) :
        name(name),
        function(reinterpret_cast<MemberFunction>(method)),
        numArguments(sizeof...(Args)),
        returnTypeSize(getReturnSize<Ret>())
      {
#ifdef _DEBUG
        setSizes<Args...>();
#endif
      }
 
      Method(const Method & other) = default;
 
      Method(Method && other) noexcept = default;
 
      Method & operator=(const Method & other) = default;
 
      Method & operator=(Method && other) noexcept = default;
 
      template<typename Ret>
      size_t getReturnSize() const
      {
        return sizeof(Ret);
      }
 
      template<typename... Args>
      void setSizes()
      {
        size_t sizes[] = { (sizeof(Args))... };
        static_assert(kMaxMethodArguments >= sizeof...(Args));
 
        for (size_t i = 0; i < numArguments; ++i) {
          argumentSizes[i] = sizes[i];
        }
      }
 
      template<typename... Args>
      void compareSizes() const
      {
        size_t sizes [] = { (sizeof(Args))... };
        static_assert(kMaxMethodArguments >= sizeof...(Args));
 
        for (size_t i = 0; i < numArguments; ++i) {
          assert(argumentSizes[i] == sizes[i] && "Argument passed to method not of correct type or size");
        }
      }
 
      template<typename Class, typename... Arg>
      void call(Class * object, Arg... arg) const
      {
        assert(numArguments == sizeof...(Arg) && "Method does not support being called with the given number of arguments.");
 
#ifdef _DEBUG
        compareSizes<Arg...>();
#endif
 
        typedef void (Class::*TypedMessage)(Arg...);
        
        auto method = reinterpret_cast<TypedMessage>(function);
 
        (object->*method)(arg...);
      }
 
      template<typename Class, typename Ret, typename... Arg>
      Ret callWithReturn(Class * object, Ret, Arg... arg) const
      {
        assert(returnTypeSize == getReturnSize<Ret>() && "Method does not have correct return type or size.");
        assert(numArguments == sizeof...(Arg) && "Method does not support being called with the given number of arguments.");
 
#ifdef _DEBUG
        compareSizes<Arg...>();
#endif
 
        typedef Ret (Class::*TypedMessage)(Arg...);
 
        auto method = reinterpret_cast<TypedMessage>(function);
 
        return (object->*method)(arg...);
      }
 
      const Name & getName() const { return name; }
 
    private:
      Name name;
 
      MemberFunction function;
 
      size_t numArguments;
 
      size_t returnTypeSize;
 
      size_t argumentSizes[kMaxMethodArguments] = {};
    };
 
    template<>
    inline size_t Method::getReturnSize<void>() const
    {
      return 0;
    }
    
    template<>
    inline void Method::setSizes<>()
    {
 
    }
 
    template<>
    inline void Method::compareSizes<>() const
    {
 
    }
  }
}