verb-visitor.hpp

Go to the documentation of this file.

/*
  VERB-VISITOR.hpp  -  double dispatch to arbitrary functions on a common interface
 
   Copyright (C)
     2019,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_VERB_VISITOR_H
#define LIB_VERB_VISITOR_H
 
 
#include "lib/meta/variadic-helper.hpp"
#include "lib/polymorphic-value.hpp"
#include "lib/verb-token.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"
 
#include <utility>
#include <string>
#include <tuple>
 
 
namespace lib {
  
  namespace {
    using JustSomeIrrelvantType = struct{};
    const size_t VERB_TOKEN_SIZE = sizeof(VerbToken<JustSomeIrrelvantType, void(void)>);
    
    constexpr size_t
    storageOverhead(size_t argStorage)
    {
      return argStorage + VERB_TOKEN_SIZE;
    }
  }
  
  
  template<class REC, class RET>
  struct VerbInvoker
    : polyvalue::CloneValueSupport<polyvalue::EmptyBase> // mark and mix-in virtual copy construction support
    {
      virtual ~VerbInvoker() { }
      
      virtual RET applyTo (REC&)    =0;
      virtual Literal getID() const =0;
      
      bool operator== (VerbInvoker const& o)  const { return getID() == o.getID(); }
      bool operator!= (VerbInvoker const& o)  const { return getID() != o.getID(); }
    };
  
  
  template<class REC, class SIG>
  struct VerbHolder;
  
  template<class REC, class RET, typename... ARGS>
  struct VerbHolder<REC, RET(ARGS...)>
    : VerbInvoker<REC,RET>
    , VerbToken<REC,RET(ARGS...)>
    {
      using Verb = VerbToken<REC,RET(ARGS...)>;
      using Args = std::tuple<ARGS...>;
      
      using SequenceIterator = meta::BuildIdxIter<ARGS...>::Ascending;
      
      Args args_;
      
      template<typename...PARS>
      VerbHolder (Verb::Handler handlerRef, Literal verbID, PARS&&... args)
        : Verb{handlerRef, verbID}
        , args_{std::forward<PARS> (args)...}
        { }
      
      Literal
      getID()  const override
        {
          return Verb::getID();
        }
      
      RET
      applyTo (REC& receiver)  override
        {
          return invokeVerb (receiver, SequenceIterator());
        }
      
    private:
      template<size_t...idx>
      RET
      invokeVerb (REC& receiver, meta::IndexSeq<idx...>)
        {
          return (receiver.*Verb::handler_) (std::get<idx> (args_)...);
        }
    };
  
  
  
  /******************************************************************************************/
  template<class REC, class RET, size_t arg_storage>
  class VerbPack
    : public PolymorphicValue<VerbInvoker<REC,RET>, storageOverhead(arg_storage)>
    {
      using Dispatcher = VerbInvoker<REC,RET>; // the interface to talk to our payload
      using PolyHolder = PolymorphicValue<Dispatcher, storageOverhead(arg_storage)>;
      
      template<typename FUN>
      struct HandlerTypeDetector
        {
          static_assert (!sizeof(FUN), "handler must be a function member pointer for the given receiver");
        };
      template<typename...ARGS>
      struct HandlerTypeDetector<RET (REC::*) (ARGS...)>
        {
          using Verb    = VerbToken<REC, RET(ARGS...)>;
          using Payload = VerbHolder<REC, RET(ARGS...)>;
        };
      
      template<typename FUN>
      using PayloadType = HandlerTypeDetector<FUN>::Payload *;
      
      
    public:
      template<typename FUN, typename...ARGS>
      VerbPack (FUN handler, Literal verbID, ARGS&&... args)
        : PolyHolder(PayloadType<FUN>(), handler, verbID, std::forward<ARGS>(args)...)
        { }
      
      RET
      applyTo (REC& receiver)
        {
          return PolyHolder::getPayload().applyTo (receiver);
        }
      
      operator string()  const
        {
          return "VerbPack("
               + string{util::unConst(this)->getPayload().getID()}
               + ")";
        }
      
      template<typename ARG>
      ARG&
      accessArg ()
        {
          using EmbeddedPayload = lib::VerbHolder<REC, RET(ARG)>;
          REQUIRE (INSTANCEOF (EmbeddedPayload, &this->getPayload()));
          EmbeddedPayload& embedded = static_cast<EmbeddedPayload&>(this->getPayload());
          return std::get<0> (embedded.args_);
        }
    };
  
  
  
} // namespace lib
#endif /*LIB_VERB_VISITOR_H*/