feed-manifold.hpp

Go to the documentation of this file.

/*
  FEED-MANIFOLD.hpp  -  data feed connection system for render nodes
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
     2023,            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 ENGINE_FEED_MANIFOLD_H
#define ENGINE_FEED_MANIFOLD_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "steam/engine/buffhandle.hpp"
#include "lib/uninitialised-storage.hpp"
#include "lib/meta/function.hpp"
#include "lib/meta/trait.hpp"
#include "lib/meta/typeseq-util.hpp"
#include "lib/meta/variadic-helper.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/meta/generator.hpp"
#include "lib/test/test-helper.hpp"
 
 
namespace steam {
namespace engine {
  
  namespace {// Introspection helpers....
    
    using lib::meta::_Fun;
    using lib::meta::enable_if;
    using lib::meta::is_UnaryFun;
    using lib::meta::is_BinaryFun;
    using lib::meta::is_TernaryFun;
    using lib::meta::tuple_like;
    using lib::meta::forEachIDX;
    using lib::meta::ElmTypes;
    using lib::meta::Tagged;
    using lib::meta::Types;
    using lib::meta::Nil;
    using std::is_pointer;
    using std::is_reference;
    using std::is_convertible;
    using std::is_constructible;
    using std::is_copy_constructible;
    using std::remove_pointer_t;
    using std::tuple_element_t;
    using std::add_pointer_t;
    using std::conditional_t;
    using std::__and_;
    using std::__not_;
    
    
    template<typename V>
    struct is_Value
      : __and_<__not_<is_pointer<V>>
              ,__not_<is_reference<V>>
              ,std::is_default_constructible<V>
              ,std::is_copy_assignable<V>
              >
      { };
    
    template<typename B>
    struct is_Buffer
      : __and_<is_pointer<B>
              ,__not_<_Fun<B>>
              ,std::is_default_constructible<remove_pointer_t<B>>
              >
      { };
    
    
    
    
    template<class FUN>
    struct _ProcFun
      {
        static_assert(_Fun<FUN>()           , "something funktion-like required");
        static_assert(0 <  _Fun<FUN>::ARITY , "function with at least one argument expected");
        static_assert(3 >= _Fun<FUN>::ARITY , "function with up to three arguments accepted");
        
        using Sig  = _Fun<FUN>::Sig;
        
        template<size_t i>
        using _Arg = lib::meta::Pick<typename _Fun<Sig>::Args, i>::Type;
        
        template<size_t i, template<class> class COND>
        using AllElements = ElmTypes<_Arg<i>>::template AndAll<COND>;
        
        template<size_t i>
        static constexpr bool nonEmpty   =   ElmTypes<_Arg<i>>::SIZ;
        template<size_t i>
        static constexpr bool is_BuffSlot =  AllElements<i, is_Buffer>();
        template<size_t i>
        static constexpr bool is_ParamSlot = AllElements<i, is_Value>();
 
        template<class SIG,  typename SEL =void>
        struct _Case
          {
            static_assert (not sizeof(SIG), "use case could not be determined from function signature");
          };
        template<class SIG>
        struct _Case<SIG,   enable_if<is_UnaryFun<SIG>>>
          {
            enum{ SLOT_O = 0
                , SLOT_I = 0
            };
          };
        template<class SIG>
        struct _Case<SIG,   enable_if<is_BinaryFun<SIG>>>
          {
            enum{ SLOT_O = 1
                , SLOT_I = (nonEmpty<0> and is_BuffSlot<0>)? 0 : 1
            };
          };
        template<class SIG>
        struct _Case<SIG,   enable_if<is_TernaryFun<SIG>>>
          {
            enum{ SLOT_O = 2
                , SLOT_I = 1
            };
          };
        
        using SigI = _Arg<_Case<Sig>::SLOT_I>;
        using SigO = _Arg<_Case<Sig>::SLOT_O>;
        using SigP = _Arg< 0>;
        using ArgI = ElmTypes<SigI>::Seq;
        using ArgO = ElmTypes<SigO>::Seq;
        using ArgP = ElmTypes<SigP>::Seq;
        
        // Metaprogramming helper for Buffer types (sans pointer)
        using ElmsI = ElmTypes<typename ElmTypes<SigI>::template Apply<remove_pointer_t>>;
        using ElmsO = ElmTypes<typename ElmTypes<SigO>::template Apply<remove_pointer_t>>;
        
        enum{ FAN_I = ElmTypes<SigI>::SIZ
            , FAN_O = ElmTypes<SigO>::SIZ
            , FAN_P = ElmTypes<SigP>::SIZ
            , SLOT_I = _Case<Sig>::SLOT_I
            , SLOT_O = _Case<Sig>::SLOT_O
            , SLOT_P =  0
            };
        
        static constexpr bool hasInput() { return SLOT_I != SLOT_O; }
        static constexpr bool hasParam() { return 0 < SLOT_I; }
        
        /* ========== |consistency checks| ========== */
        static_assert (nonEmpty<SLOT_O> or nonEmpty<SLOT_I> or nonEmpty<SLOT_P>
                      ,"At least one slot of the function must accept data");
        static_assert (is_BuffSlot<SLOT_O>, "Output slot of the function must accept buffer pointers");
        static_assert (is_BuffSlot<SLOT_I>, "Input slot of the function must accept buffer pointers");
        static_assert (is_ParamSlot<SLOT_P> or not hasParam()
                      ,"Param slot must accept value data");
      };
    
    
    template<class FUN>
    struct _ParamFun
      {
        using _Proc = _ProcFun<FUN>;
        
        static constexpr bool hasParam() { return _Proc::hasParam(); }
        
        using Param = conditional_t<hasParam(), typename _Proc::SigP, std::tuple<>>;
        
        template<class PF>
        using Res = _Fun<PF>::Ret;
        template<class PF>
        using SigP = add_pointer_t<typename _Fun<PF>::Sig>;
        
        template<class PF>
        using isSuitable  = is_constructible<Param, Res<PF>>;
        template<class PF>
        using canInvoke  = std::is_invocable<PF, TurnoutSystem&>;
        
        template<class PF>
        using isConfigurable = __and_<is_constructible<bool, PF&>
                                     ,__not_<is_convertible<PF&, SigP<PF>>>
                                     >;   // non-capture-λ are convertible via function-ptr to bool
                                         //  yet we want to detect a real built-in bool-conversion.
        template<class PF>
        static bool
        isActivated (PF const& paramFun)
          {
            if constexpr (isSuitable<PF>())
              { if constexpr (isConfigurable<PF>())
                  return bool(paramFun);
                else
                  return true;
              }
            return false;
          }
        
        
        template<class PF>
        static constexpr bool canAdapt()    { return isSuitable<PF>();                          }
        template<class PF>
        static constexpr bool isParamFun()  { return isSuitable<PF>() and canInvoke<PF>();      }
        template<class PF>
        static constexpr bool canActivate() { return isSuitable<PF>() and isConfigurable<PF>(); }
      };
    
    struct _Disabled
      {
        void operator() (void) const {/*I do make a difference, I really do!*/}
      };
    
  }//(End)Introspection helpers.
  
  
  
  template<class FUN, class PAM =_Disabled>
  class FeedPrototype;
  
  
  template<class FUN>
  struct _StorageSetup
    {
      using _Trait = _ProcFun<FUN>;
      
      static constexpr bool hasInput() { return _Trait::hasInput(); }
      static constexpr bool hasParam() { return _Trait::hasParam(); }
      
      enum{ FAN_P = hasParam()? _Trait::FAN_P : 0
          , FAN_I = hasInput()? _Trait::FAN_I : 0
          , FAN_O = _Trait::FAN_O
          };
      
      template<size_t fan>
      using BuffS = lib::UninitialisedStorage<BuffHandle, fan>;
                                           // ^^^ can not be default-constructed
      using BuffI = BuffS<FAN_I>;
      using BuffO = BuffS<FAN_O>;
      
      using Param = conditional_t<hasParam(), typename _Trait::SigP, std::tuple<>>;
      using ArgI  = conditional_t<hasInput(), typename _Trait::SigI, std::tuple<>>;
      using ArgO  = _Trait::SigO;
      
      
      struct ParamStorage
        {
          Param param;
          
          ParamStorage()
            : param{}
            { }
          
          template<typename...INIT>
          ParamStorage (INIT&& ...paramInit)
            : param{forward<INIT> (paramInit)...}
            { }                                                                 
        };
      
      struct BufferSlot_Input
        {
          BuffI inBuff;
          ArgI  inArgs{};
        };
      
      struct BufferSlot_Output
        {
          BuffO outBuff;
          ArgO  outArgs{};
        };
      
      template<typename F>
      using enable_if_hasParam  = lib::meta::enable_if_c<_ProcFun<F>::hasParam()>::type;
      
      template<class X>
      using NotProvided = Tagged<Nil, X>;
      
      template<bool yes, class B>
      using Provide_if = conditional_t<yes, B, NotProvided<B>>;
      
      using FeedOutput =                         BufferSlot_Output;
      using FeedInput  = Provide_if<hasInput(),  BufferSlot_Input>;
      using FeedParam  = Provide_if<hasParam(),  ParamStorage>;
      
      struct Storage
        : util::NonCopyable
        , FeedOutput
        , FeedInput
        , FeedParam
        {
          FUN process;
          
          template<typename F>
          Storage (F&& fun)
            : process{forward<F> (fun)}
            { }
          
          template<typename F,         typename =enable_if_hasParam<F>>
          Storage (Param p, F&& fun)
            : FeedParam{move (p)}
            , process{forward<F> (fun)}
            { }
        };
    };
  
  
  template<class FUN>
  struct FeedManifold
    : _StorageSetup<FUN>::Storage
    {
      using _T = _ProcFun<FUN>;
      using _S = _StorageSetup<FUN>;
      using _F = _S::Storage;
      
      using _S::Storage::Storage;
      
      using ArgI  = _S::ArgI;
      using ArgO  = _S::ArgO;
      using Param = _S::Param;
      enum{ FAN_I = _S::FAN_I
          , FAN_O = _S::FAN_O
          , FAN_P = _S::FAN_P
          };
      
      static constexpr bool hasInput() { return _S::hasInput(); }
      static constexpr bool hasParam() { return _S::hasParam(); }
      
      
      using Prototype = FeedPrototype<FUN>;
      
      
      
      template<size_t i, class ARG>
      auto&
      accessArg (ARG& arg)
        {
          if constexpr (tuple_like<ARG>)
            return lib::meta::getElm<i> (arg);
          else
            return arg;
        }
      
      using TupI = _T::ElmsI::Tup;
      using TupO = _T::ElmsO::Tup;
      
      
      void
      connect()
        {
          if constexpr (hasInput())
          {
            forEachIDX<TupI> ([&](auto i)
                                {
                                  using BuffI = tuple_element_t<i, TupI>;
                                  accessArg<i> (_F::inArgs) = & _F::inBuff[i].template accessAs<BuffI>();
                                });
          }
          // always wire output buffer(s)
          {
            forEachIDX<TupO> ([&](auto i)
                                {
                                  using BuffO = tuple_element_t<i, TupO>;
                                  accessArg<i> (_F::outArgs) = & _F::outBuff[i].template accessAs<BuffO>();
                                });
          }
        }
      
      void
      invoke()
        {
          if constexpr (hasParam())
            if constexpr (hasInput())
              _F::process (_F::param, _F::inArgs, _F::outArgs);
            else
              _F::process (_F::param, _F::outArgs);
          else
            if constexpr (hasInput())
              _F::process (_F::inArgs, _F::outArgs);
            else
              _F::process (_F::outArgs);
        }
    };
  
  
  
  template<class FUN, class PAM>
  class FeedPrototype
    : util::MoveOnly
    {
      using _Proc = _ProcFun<FUN>;
      using _Trait = _ParamFun<FUN>;
      
      FUN procFun_;
      PAM paramFun_;
      
    public:
      using Feed = FeedManifold<FUN>;
      enum{ FAN_I = Feed::FAN_I
          , FAN_O = Feed::FAN_O
          , FAN_P = Feed::FAN_P
      };
      using ElmsI = _Proc::ElmsI;
      using ElmsO = _Proc::ElmsO;
      using ElmsP = conditional_t<_Trait::hasParam(), typename _Proc::ArgP, Types<>>;
      using Param = _Proc::SigP;
      
      template<template<class> class META>
      using OutTypesApply = ElmsO::template Apply<META>;
      
      
      FeedPrototype (FUN&& proc)
        : procFun_{move (proc)}
        , paramFun_{}
        { }
      
      FeedPrototype (FUN&& proc, PAM&& par)
        : procFun_{move (proc)}
        , paramFun_{move (par)}
        { }
      // default move acceptable : pass pre-established setup
      
      static constexpr bool hasParam()    { return _Trait::hasParam(); }
      static constexpr bool hasParamFun() { return _Trait::template isParamFun<PAM>();  }
      static constexpr bool canActivate() { return _Trait::template canActivate<PAM>(); }
      
      bool isActivated()  const           { return _Trait::isActivated(paramFun_); }
      
      
      
      /************************************************************/
      Feed
      buildFeed (TurnoutSystem& turnoutSys)
        {
          if constexpr (hasParamFun())
            if (isActivated())
              return Feed(paramFun_(turnoutSys), procFun_);
          return Feed{procFun_};
        }
      
      
      
      /* ======= cross-builder API ======= */
      
      using ProcFun = FUN;
      using ParamFun = PAM;
      
      template<typename PFX>
      using Adapted = FeedPrototype<FUN,PFX>;
      
      template<typename PFX>
      static constexpr bool isSuitableParamFun()
        {
          return hasParam() and _Trait::template isParamFun<PFX>();
        }
      template<typename PFX>
      static constexpr bool isSuitableParamAdaptor()
        {
          return hasParam() and _Trait::template canAdapt<PFX>();
        }
      
      template<typename PFX>
      auto
      moveAdaptedParam (PFX otherParamFun =PFX{})
        {
          using OtherParamFun = std::decay_t<PFX>;
          return Adapted<OtherParamFun>{move(procFun_), move(otherParamFun)};
        }
      
      
      enable_if<__and_<is_copy_constructible<FUN>
                      ,is_copy_constructible<PAM>>, FeedPrototype>
      clone()  const
        {
          return FeedPrototype{FUN(procFun_), PAM(paramFun_)};
        }
      
      template<typename PFX =PAM,      typename = enable_if<std::is_assignable<PAM,PFX>>>
      FeedPrototype&&
      assignParamFun (PFX&& paramFunDef =PAM{})
        {
          paramFun_ = forward<PFX> (paramFunDef);
          return move(*this);
        }
      
      
      template<typename TRA>
      auto
      decorateProcParam (TRA paramTransformer)
        {
          static_assert (_Trait::hasParam(), "Processing-functor with parameters expected");
          static_assert (isSuitableParamAdaptor<TRA>(), "Given functor's output not suitable "
                                             "for adapting the proc-functor's 1st argument");
          using SigP = lib::meta::_FunArg<TRA>;
          using SigI = _Proc::SigI;
          using SigO = _Proc::SigO;
          if constexpr (_Proc::hasInput())
            {
              return [procFun = move(procFun_)
                     ,transform = move(paramTransformer)
                     ]
                     (SigP par, SigI in, SigO out)
                      {
                        return procFun (transform(par), in, out);
                      };
            }
          else
            {
              return [procFun = move(procFun_)
                     ,transform = move(paramTransformer)
                     ]
                     (SigP par, SigO out)
                      {
                        return procFun (transform(par), out);
                      };
            }
        }
      
      template<typename TRA>
      using DecoratedProcFun = decltype(std::declval<FeedPrototype>().decorateProcParam (std::declval<TRA>()));
      
      template<typename TRA>
      using Decorated = FeedPrototype<DecoratedProcFun<TRA>,PAM>;
      
      template<typename TRA>
      auto
      moveTransformedParam (TRA paramTransformer)
        {
          return Decorated<TRA>{decorateProcParam (move(paramTransformer)), move(paramFun_)};
        }
 
    };
  
}} // namespace steam::engine
#endif /*ENGINE_FEED_MANIFOLD_H*/