FunctionMethod.h

 
#ifndef MFRAME_F6D62182_CA3A_4CCA_82D2_44B456A08840
#define MFRAME_F6D62182_CA3A_4CCA_82D2_44B456A08840
 
/* ***************************************************************************************
 * Include
 */
 
//----------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------
#include "./../func/Function.h"
#include "./../lang/Object.h"
 
/* ***************************************************************************************
 * Namespace
 */
namespace ufm::func {
  class FunctionMethod;
}  // namespace ufm::func
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
 
class ufm::func::FunctionMethod final : public Object, public ufm::func::Function<> {
  /* *************************************************************************************
   * Variable
   */
 private:
  Interface& vClass;
 
  Interface& (Interface::*vMethod)(Interface&);
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  template <typename T = Interface, typename R = Interface, typename C = Interface>
  FunctionMethod(Interface& c, Interface& (C::*method)(Interface&)) : vClass(c) {
    this->vMethod = reinterpret_cast<Interface& (Interface::*)(Interface&)>(method);
    return;
  }
 
  template <typename T = Interface, typename R = Interface>
  FunctionMethod(Function<T, R>& function)
      : FunctionMethod(function, Function<T, R>::apply) {
    return;
  }
 
  virtual ~FunctionMethod(void) override;
 
  /* *************************************************************************************
   * Operator Method
   */
 public:
  template <typename T, typename R>
  inline operator const Function<T, R>&(void) const {
    const Function<>* src = this;
    return *reinterpret_cast<const Function<T, R>*>(src);
  }
 
  template <typename T, typename R>
  inline operator Function<T, R>&(void) {
    Function<>* src = this;
    return *reinterpret_cast<Function<T, R>*>(src);
  }
 
  /* *************************************************************************************
   * Override Method - ufm::func::Function<Interface, Interface>
   */
 public:
  virtual Interface& apply(Interface& t) override;
 
  /* *************************************************************************************
   * Public Method
   */
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MFRAME_F6D62182_CA3A_4CCA_82D2_44B456A08840 */