nodeinvocation-obsolete.hpp

Go to the documentation of this file.

/*
  NODEINVOCATION.hpp  -  Organise the invocation state within a single pull() call

   Copyright (C)
     2008,            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_NODEINVOCATION_H
#define ENGINE_NODEINVOCATION_H


//#include "steam/engine/proc-node.hpp"    ///////////////////////////////TODO clarify if required further on
#include "steam/engine/connectivity-obsolete.hpp"
#include "steam/engine/state-closure-obsolete.hpp"
#include "steam/engine/channel-descriptor-obsolete.hpp"
#include "steam/engine/feed-manifold-obsolete.hpp"




namespace steam {
namespace engine {
  
  
  class StateAdapter
    : public StateClosure_OBSOLETE
    {
    protected:
      StateClosure_OBSOLETE& parent_;
      StateClosure_OBSOLETE& current_;
      
      StateAdapter (StateClosure_OBSOLETE& callingProcess)
        : parent_ (callingProcess),
          current_(callingProcess.getCurrentImplementation())
        { }
      
      virtual StateClosure_OBSOLETE& getCurrentImplementation () { return current_; }
      
      
      
    public: /* === proxying the StateClosure interface === */
      
      virtual void releaseBuffer (BuffHandle& bh)       { current_.releaseBuffer (bh); }
      
      virtual void is_calculated (BuffHandle const& bh) { current_.is_calculated (bh); }
      
      virtual BuffHandle fetch (FrameID const& fID)     { return current_.fetch (fID); }
      
      virtual BuffTableStorage& getBuffTableStorage()   { return current_.getBuffTableStorage(); }

      // note: allocateBuffer()  is chosen specifically based on the actual node wiring
      
    };
  
  
  
  
  
  struct Invocation
    : StateAdapter
    {
      Connectivity const& wiring;
      const uint outNr;
      
      FeedManifold* feedManifold;
      
    protected:
      Invocation (StateClosure_OBSOLETE& callingProcess, Connectivity const& w, uint o)
        : StateAdapter(callingProcess),
          wiring(w), outNr(o),
          feedManifold(0)
        { }
      
    public:
      uint nrO()          const { return wiring.nrO; }
      uint nrI()          const { return wiring.nrI; }
      uint buffTabSize()  const { return nrO()+nrI(); }
      
      void setBuffTab (FeedManifold* b) { this->feedManifold = b; }
      
      bool
      buffTab_isConsistent ()
        {
          return (feedManifold)
              && (0 < buffTabSize())
              && (nrO()+nrI() <= buffTabSize())
              && (feedManifold->inBuff   == &feedManifold->outBuff[nrO()]  )
              && (feedManifold->inHandle == &feedManifold->outHandle[nrO()])
               ;
        }
      
      
    public:
      virtual FrameID const&
      genFrameID ()
        {
          return current_.genFrameID(wiring.nodeID, outNr);
        }
      
      virtual FrameID const&
      genFrameID (NodeID const& nID, uint chanNo)
        {
          return current_.genFrameID (nID,chanNo);
        }
      
    };
    
    
  struct AllocBufferFromParent  
    : Invocation
    {
      AllocBufferFromParent (StateClosure_OBSOLETE& sta, Connectivity const& w, const uint outCh)
        : Invocation(sta, w, outCh) {}
      
      virtual BuffHandle
      allocateBuffer (const lumiera::StreamType* ty) { return parent_.allocateBuffer(ty); }          
    };
  
  struct AllocBufferFromCache   
    : Invocation
    {
      AllocBufferFromCache (StateClosure_OBSOLETE& sta, Connectivity const& w, const uint outCh)
        : Invocation(sta, w, outCh) {}
      
      virtual BuffHandle
      allocateBuffer (const lumiera::StreamType* ty) { return current_.allocateBuffer(ty); }
    };
  
  
  template<class Strategy, class BufferProvider>
  class ActualInvocationProcess
    : public BufferProvider
    , private Strategy
    {
    public:
      ActualInvocationProcess (StateClosure_OBSOLETE& callingProcess, Connectivity const& w, const uint outCh)
        : BufferProvider(callingProcess, w, outCh)
        { }
      
      BuffHandle retrieve ()
        {
          return Strategy::step (*this);
        }
    };
  
  
  
  
}} // namespace steam::engine
#endif