nodeinvocation.hpp

Go to the documentation of this file.

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

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


#include "steam/state.hpp"
#include "steam/engine/procnode.hpp"
#include "steam/engine/channel-descriptor.hpp"
#include "steam/engine/bufftable-obsolete.hpp"




namespace steam {
namespace engine {
  
  
  class StateAdapter
    : public State
    {
    protected:
      State& parent_;
      State& current_;
      
      StateAdapter (State& callingProcess) 
        : parent_ (callingProcess),
          current_(callingProcess.getCurrentImplementation())
        { }
      
      virtual State& getCurrentImplementation () { return current_; }
      
      
      
    public: /* === proxying the State 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
    {
      WiringDescriptor const& wiring;
      const uint outNr;
      
      BuffTable* buffTab;
      
    protected:
      Invocation (State& callingProcess, WiringDescriptor const& w, uint o)
        : StateAdapter(callingProcess),
          wiring(w), outNr(o),
          buffTab(0)
        { }
      
    public:
      uint nrO()          const { return wiring.nrO; }
      uint nrI()          const { return wiring.nrI; }
      uint buffTabSize()  const { return nrO()+nrI(); }
      
      void setBuffTab (BuffTable* b) { this->buffTab = b; }
      
      bool
      buffTab_isConsistent ()
        {
          return (buffTab)
              && (0 < buffTabSize())
              && (nrO()+nrI() <= buffTabSize())
              && (buffTab->inBuff   == &buffTab->outBuff[nrO()]  )
              && (buffTab->inHandle == &buffTab->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 (State& sta, WiringDescriptor const& w, const uint outCh) 
          : Invocation(sta, w, outCh) {}
        
        virtual BuffHandle
        allocateBuffer (const lumiera::StreamType* ty) { return parent_.allocateBuffer(ty); }          
      };
    
    struct AllocBufferFromCache   
      : Invocation
      {
        AllocBufferFromCache (State& sta, WiringDescriptor 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 (State& callingProcess, WiringDescriptor const& w, const uint outCh)
        : BufferProvider(callingProcess, w, outCh)
        { }
      
      BuffHandle retrieve ()
        {
          return Strategy::step (*this);
        }
    };
  
  
  
  
}} // namespace steam::engine
#endif