verb-visitor.hpp

Go to the documentation of this file.

/*
  VERB-VISITOR.hpp  -  double dispatch to arbitrary functions on a common interface

  Copyright (C)         Lumiera.org
    2019,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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 = typename meta::BuildIdxIter<ARGS...>::Ascending;
      
      Args args_;
      
      template<typename...PARS>
      VerbHolder (typename 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 = typename 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*/