delegate_cpp03.h

 
//
//The MIT License(MIT)
//
//Embedded Template Library.
//https://github.com/ETLCPP/etl
//https://www.etlcpp.com
//
//Copyright(c) 2021 John Wellbelove
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files(the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//******************************************************************************/
 
//
//Copyright (C) 2017 by Sergey A Kryukov: derived work
//http://www.SAKryukov.org
//http://www.codeproject.com/Members/SAKryukov
//
//Based on original work by Sergey Ryazanov:
//"The Impossibly Fast C++ Delegates", 18 Jul 2005
//https://www.codeproject.com/articles/11015/the-impossibly-fast-c-delegates
//
//MIT license:
//http://en.wikipedia.org/wiki/MIT_License
//
//Original publication: https://www.codeproject.com/Articles/1170503/The-Impossibly-Fast-Cplusplus-Delegates-Fixed
//
//******************************************************************************/
 
#ifndef ETL_DELEGATE_CPP03_INCLUDED
#define ETL_DELEGATE_CPP03_INCLUDED
 
#include "../platform.h"
#include "../error_handler.h"
#include "../exception.h"
#include "../type_traits.h"
#include "../utility.h"
#include "../optional.h"
 
#if defined(ETL_IN_DELEGATE_CPP03_UNIT_TEST)
namespace etl_cpp03
#else
namespace etl
#endif
{
  namespace private_delegate
  {
    //***********************************
    template <typename TDelegate, typename TReturn, typename TParam>
    struct call_if_impl
    {    
      etl::optional<TReturn> call_if(TParam param)
      {
                TDelegate& d = static_cast<TDelegate&>(*this);
                
        etl::optional<TReturn> result;
 
        if (d.is_valid())
        {
          result = d(param);
        }
 
        return result;
      }
    };
 
    //***********************************
    template <typename TDelegate>
    struct call_if_impl<TDelegate, void, void>
    {
      bool call_if()
      {
                TDelegate& d = static_cast<TDelegate&>(*this);
                
        if (d.is_valid())
        {
          d();
          return true;
        }
        else
        {
          return false;
        }
      }
    };
 
    //***********************************
    template <typename TDelegate, typename TReturn>
    struct call_if_impl<TDelegate, TReturn, void>
    {
      etl::optional<TReturn> call_if()
      {
                TDelegate& d = static_cast<TDelegate&>(*this);
                
        etl::optional<TReturn> result;
 
        if (d.is_valid())
        {
          result = d();
        }
 
        return result;
      }
    };
 
    //***********************************
    template <typename TDelegate, typename TParam>
    struct call_if_impl<TDelegate, void, TParam>
    {
      bool call_if(TParam param)
      {
        TDelegate& d = static_cast<TDelegate&>(*this);
 
        if (d.is_valid())
        {
          d(param);
          return true;
        }
        else
        {
          return false;
        }
      }
    };
  }
 
  //***************************************************************************
  //***************************************************************************
  class delegate_exception : public etl::exception
  {
  public:
 
    delegate_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
      : exception(reason_, file_name_, line_number_)
    {
    }
  };
 
  //***************************************************************************
  //***************************************************************************
  class delegate_uninitialised : public delegate_exception
  {
  public:
 
    delegate_uninitialised(string_type file_name_, numeric_type line_number_)
      : delegate_exception(ETL_ERROR_TEXT("delegate:uninitialised", ETL_DELEGATE_FILE_ID"A"), file_name_, line_number_)
    {
    }
  };
 
  //*************************************************************************
  //*************************************************************************
  template <typename T>
  class delegate;
 
  template <typename TReturn, typename TParam>
  class delegate<TReturn(TParam)> : public private_delegate::call_if_impl<delegate<TReturn(TParam)>, TReturn, TParam>
  {
  private:
 
    typedef delegate<TReturn(TParam)> delegate_type;
 
  public:
 
    using private_delegate::call_if_impl<delegate<TReturn(TParam)>, TReturn, TParam>::call_if;
 
    //*************************************************************************
    //*************************************************************************
    delegate()
    {
    }
 
    //*************************************************************************
    // Copy constructor.
    //*************************************************************************
    delegate(const delegate& other)
    {
      invocation = other.invocation;
    }
 
    //*************************************************************************
    // Construct from a functor.
    //*************************************************************************
    template <typename TFunctor>
    delegate(TFunctor& instance, typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, int>::type = 0)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    // Construct from a const functor.
    //*************************************************************************
    template <typename TFunctor>
    delegate(const TFunctor& instance, typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, int>::type = 0)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)(TParam)>
    static delegate create()
    {
      return delegate(ETL_NULLPTR, function_stub<Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static 
      typename etl::enable_if<etl::is_class<TFunctor>::value &&!etl::is_same<delegate_type, TFunctor>::value, delegate>::type
      create(TFunctor& instance)
    {
      return delegate((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static
      typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate>::type
      create(const TFunctor& instance)
    {
      return delegate((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::*Method)(TParam)>
    static delegate create(T& instance)
    {
      return delegate((void*)(&instance), method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::*Method)(TParam) const>
    static delegate create(const T& instance)
    {
      return delegate((void*)(&instance), const_method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::*Method)(TParam)>
    static delegate create()
    {
      return delegate(method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T const& Instance, TReturn(T::*Method)(TParam) const>
    static delegate create()
    {
      return delegate(const_method_instance_stub<T, Instance, Method>);
    }
 
#if !(defined(ETL_COMPILER_GCC) && (__GNUC__ <= 8))
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance>
    static delegate create()
    {
      return delegate(operator_instance_stub<T, Instance>);
    }
#endif
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)(TParam)>
    void set()
    {
      assign(ETL_NULLPTR, function_stub<Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, void>::type
      set(TFunctor& instance)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, void>::type
      set(const TFunctor& instance)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)(TParam)>
    void set(T& instance)
    {
      assign((void*)(&instance), method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)(TParam) const>
    void set(T& instance)
    {
      assign((void*)(&instance), const_method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::* Method)(TParam)>
    void set()
    {
      assign(ETL_NULLPTR, method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T const& Instance, TReturn(T::* Method)(TParam) const>
    void set()
    {
      assign(ETL_NULLPTR, const_method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    ETL_CONSTEXPR14 void clear()
    {
      invocation.clear();
    }
 
    //*************************************************************************
    //*************************************************************************
    TReturn operator()(TParam param) const
    {
      ETL_ASSERT(is_valid(), ETL_ERROR(delegate_uninitialised));
 
      return (*invocation.stub)(invocation.object, param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TAlternative>
    TReturn call_or(TAlternative alternative, TParam param) const
    {
      if (is_valid())
      {
        return (*invocation.stub)(invocation.object, param);
      }
      else
      {
        return alternative(param);
      }
    }
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)(TParam)>
    TReturn call_or(TParam param) const
    {
      if (is_valid())
      {
        return (*invocation.stub)(invocation.object, param);
      }
      else
      {
        return (Method)(param);
      }
    }
 
    //*************************************************************************
    //*************************************************************************
    delegate& operator =(const delegate& rhs)
    {
      invocation = rhs.invocation;
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate&>::type
      operator =(TFunctor& instance)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate&>::type
      operator =(const TFunctor& instance)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool operator == (const delegate& rhs) const
    {
      return invocation == rhs.invocation;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool operator != (const delegate& rhs) const
    {
      return invocation != rhs.invocation;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool is_valid() const
    {
      return invocation.stub != ETL_NULLPTR;
    }
 
    //*************************************************************************
    //*************************************************************************
    operator bool() const
    {
      return is_valid();
    }
 
  private:
 
    typedef TReturn(*stub_type)(void* object, TParam);
 
    //*************************************************************************
    //*************************************************************************
    struct invocation_element
    {
      invocation_element()
        : object(ETL_NULLPTR)
        , stub(ETL_NULLPTR)
            {
            }
 
      //***********************************************************************
      invocation_element(void* object_, stub_type stub_)
        : object(object_)
        , stub(stub_)
      {
      }
 
      //***********************************************************************
      bool operator ==(const invocation_element& rhs) const
      {
        return (rhs.stub == stub) && (rhs.object == object);
      }
 
      //***********************************************************************
      bool operator !=(const invocation_element& rhs) const
      {
        return (rhs.stub != stub) || (rhs.object != object);
      }
 
      //***********************************************************************
      ETL_CONSTEXPR14 void clear()
      {
        object = ETL_NULLPTR;
        stub   = ETL_NULLPTR;
      }
 
      //***********************************************************************
      void*     object;
      stub_type stub;
    };
 
    //*************************************************************************
    //*************************************************************************
    delegate(void* object, stub_type stub)
      : invocation(object, stub)
    {
    }
 
    //*************************************************************************
    //*************************************************************************
    delegate(stub_type stub)
      : invocation(ETL_NULLPTR, stub)
    {
    }
 
    //*************************************************************************
    //*************************************************************************
    void assign(void* object, stub_type stub)
    {
      invocation.object = object;
      invocation.stub   = stub;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::*Method)(TParam)>
    static TReturn method_stub(void* object, TParam param)
    {
      T* p = static_cast<T*>(object);
      return (p->*Method)(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::*Method)(TParam) const>
    static TReturn const_method_stub(void* object, TParam param)
    {
      T* const p = static_cast<T*>(object);
      return (p->*Method)(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::*Method)(TParam)>
    static TReturn method_instance_stub(void*, TParam param)
    {
      return (Instance.*Method)(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, const T& Instance, TReturn(T::*Method)(TParam) const>
    static TReturn const_method_instance_stub(void*, TParam param)
    {
      return (Instance.*Method)(param);
    }
 
#if !(defined(ETL_COMPILER_GCC) && (__GNUC__ <= 8))
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance>
    static TReturn operator_instance_stub(void*, TParam param)
    {
      return Instance.operator()(param);
    }
#endif
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)(TParam)>
    static TReturn function_stub(void*, TParam param)
    {
      return (Method)(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static TReturn functor_stub(void* object, TParam param)
    {
      TFunctor* p = static_cast<TFunctor*>(object);
      return (p->operator())(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static TReturn const_functor_stub(void* object, TParam param)
    {
      const TFunctor* p = static_cast<const TFunctor*>(object);
      return (p->operator())(param);
    }
 
    //*************************************************************************
    //*************************************************************************
    invocation_element invocation;
  };
 
  //*************************************************************************
  //*************************************************************************
  template <typename TReturn>
  class delegate<TReturn(void)> : public private_delegate::call_if_impl<delegate<TReturn(void)>, TReturn, void>
  {
  private:
 
    typedef delegate<TReturn(void)> delegate_type;
 
  public:
 
    using private_delegate::call_if_impl< delegate<TReturn(void)>, TReturn, void>::call_if;
 
    //*************************************************************************
    //*************************************************************************
    delegate()
    {
    }
 
    //*************************************************************************
    // Copy constructor.
    //*************************************************************************
    delegate(const delegate& other)
    {
      invocation = other.invocation;
    }
 
    //*************************************************************************
    // Construct from functor.
    //*************************************************************************
    template <typename TFunctor>
    delegate(TFunctor& instance, typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, int>::type = 0)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    // Construct from const functor.
    //*************************************************************************
    template <typename TFunctor>
    delegate(const TFunctor& instance, typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, int>::type = 0)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)()>
    static delegate create()
    {
      return delegate(ETL_NULLPTR, function_stub<Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static 
      typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate>::type
      create(TFunctor& instance)
    {
      return delegate((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static
      typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate>::type
      create(const TFunctor& instance)
    {
      return delegate((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)()>
    static delegate create(T& instance)
    {
      return delegate((void*)(&instance), method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)() const>
    static delegate create(const T& instance)
    {
      return delegate((void*)(&instance), const_method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::* Method)()>
    static delegate create()
    {
      return delegate(method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T const& Instance, TReturn(T::* Method)() const>
    static delegate create()
    {
      return delegate(const_method_instance_stub<T, Instance, Method>);
    }
 
#if !(defined(ETL_COMPILER_GCC) && (__GNUC__ <= 8))
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance>
    static delegate create()
    {
      return delegate(operator_instance_stub<T, Instance>);
    }
#endif
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)()>
    void set()
    {
      assign(ETL_NULLPTR, function_stub<Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, void>::type
      set(TFunctor& instance)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, void>::type
      set(const TFunctor& instance)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)()>
    void set(T& instance)
    {
      assign((void*)(&instance), method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)() const>
    void set(T& instance)
    {
      assign((void*)(&instance), const_method_stub<T, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::* Method)()>
    void set()
    {
      assign(ETL_NULLPTR, method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T const& Instance, TReturn(T::* Method)() const>
    void set()
    {
      assign(ETL_NULLPTR, const_method_instance_stub<T, Instance, Method>);
    }
 
    //*************************************************************************
    //*************************************************************************
    ETL_CONSTEXPR14 void clear()
    {
      invocation.clear();
    }
 
    //*************************************************************************
    //*************************************************************************
    TReturn operator()() const
    {
      ETL_ASSERT(is_valid(), ETL_ERROR(delegate_uninitialised));
 
      return (*invocation.stub)(invocation.object);
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TAlternative>
    TReturn call_or(TAlternative alternative) const
    {
      if (is_valid())
      {
        return (*invocation.stub)(invocation.object);
      }
      else
      {
        return alternative();
      }
    }
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)()>
    TReturn call_or() const
    {
      if (is_valid())
      {
        return (*invocation.stub)(invocation.object);
      }
      else
      {
        return (Method)();
      }
    }
 
    //*************************************************************************
    //*************************************************************************
    delegate& operator =(const delegate& rhs)
    {
      invocation = rhs.invocation;
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate&>::type
      operator =(TFunctor& instance)
    {
      assign((void*)(&instance), functor_stub<TFunctor>);
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    typename etl::enable_if<etl::is_class<TFunctor>::value && !etl::is_same<delegate_type, TFunctor>::value, delegate&>::type
      operator =(const TFunctor& instance)
    {
      assign((void*)(&instance), const_functor_stub<TFunctor>);
      return *this;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool operator == (const delegate& rhs) const
    {
      return invocation == rhs.invocation;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool operator != (const delegate& rhs) const
    {
      return invocation != rhs.invocation;
    }
 
    //*************************************************************************
    //*************************************************************************
    bool is_valid() const
    {
      return invocation.stub != ETL_NULLPTR;
    }
 
    //*************************************************************************
    //*************************************************************************
    operator bool() const
    {
      return is_valid();
    }
 
  private:
 
    typedef TReturn(*stub_type)(void* object);
 
    //*************************************************************************
    //*************************************************************************
    struct invocation_element
    {
      invocation_element()
        : object(ETL_NULLPTR)
        , stub(ETL_NULLPTR)
            {
            }
 
      //***********************************************************************
      invocation_element(void* object_, stub_type stub_)
        : object(object_)
        , stub(stub_)
      {
      }
 
      //***********************************************************************
      bool operator ==(const invocation_element& rhs) const
      {
        return (rhs.stub == stub) && (rhs.object == object);
      }
 
      //***********************************************************************
      bool operator !=(const invocation_element& rhs) const
      {
        return (rhs.stub != stub) || (rhs.object != object);
      }
 
      //***********************************************************************
      ETL_CONSTEXPR14 void clear()
      {
        object = ETL_NULLPTR;
        stub   = ETL_NULLPTR;
      }
 
      //***********************************************************************
      void* object;
      stub_type stub;
    };
 
    //*************************************************************************
    //*************************************************************************
    delegate(void* object, stub_type stub)
      : invocation(object, stub)
    {
    }
 
    //*************************************************************************
    //*************************************************************************
    delegate(stub_type stub)
      : invocation(ETL_NULLPTR, stub)
    {
    }
 
    //*************************************************************************
    //*************************************************************************
    void assign(void* object, stub_type stub)
    {
      invocation.object = object;
      invocation.stub = stub;
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)()>
    static TReturn method_stub(void* object)
    {
      T* p = static_cast<T*>(object);
      return (p->*Method)();
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, TReturn(T::* Method)() const>
    static TReturn const_method_stub(void* object)
    {
      T* const p = static_cast<T*>(object);
      return (p->*Method)();
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance, TReturn(T::* Method)()>
    static TReturn method_instance_stub(void*)
    {
      return (Instance.*Method)();
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename T, const T& Instance, TReturn(T::* Method)() const>
    static TReturn const_method_instance_stub(void*)
    {
      return (Instance.*Method)();
    }
 
#if !(defined(ETL_COMPILER_GCC) && (__GNUC__ <= 8))
    //*************************************************************************
    //*************************************************************************
    template <typename T, T& Instance>
    static TReturn operator_instance_stub(void*)
    {
      return Instance.operator()();
    }
#endif
 
    //*************************************************************************
    //*************************************************************************
    template <TReturn(*Method)()>
    static TReturn function_stub(void*)
    {
      return (Method)();
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static TReturn functor_stub(void* object)
    {
      TFunctor* p = static_cast<TFunctor*>(object);
      return (p->operator())();
    }
 
    //*************************************************************************
    //*************************************************************************
    template <typename TFunctor>
    static TReturn const_functor_stub(void* object)
    {
      const TFunctor* p = static_cast<const TFunctor*>(object);
      return (p->operator())();
    }
 
    //*************************************************************************
    //*************************************************************************
    invocation_element invocation;
  };
}
 
#endif