feed-manifold-obsolete.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_OBSOLETE_H
#define ENGINE_FEED_MANIFOLD_OBSOLETE_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "steam/engine/channel-descriptor-obsolete.hpp"
//#include "steam/engine/proc-node.hpp"    ///////////////////////////////TODO this is a dead end
#include "steam/engine/connectivity-obsolete.hpp"

#include <vector>
#include <utility>



namespace steam {
namespace engine {
  
  using std::pair;
  using std::vector;
  
  
  struct FeedManifold                 
    {
      typedef BuffHandle        * PHa;
      typedef BuffHandle::PBuff * PBu;
      typedef pair<PHa const,PBu const> Chunk;
      
      PHa outHandle;
      PHa inHandle;
      PBu outBuff;
      PBu inBuff;
    };
  
  class BuffDescr;
  
  class BuffTableStorage
    {

      struct BuffHaXXXX
        : BuffHandle
        {
          BuffHaXXXX() : BuffHandle(just_satisfy_the_compiler()) { /* wont work ever */ }
          static BuffDescr const& 
          just_satisfy_the_compiler() { }
        };
        
      vector<BuffHaXXXX>        hTab_;
      vector<BuffHandle::PBuff> pTab_;
      size_t level_;
      
    public:
      BuffTableStorage (const size_t maxSiz)
        : hTab_(maxSiz),
          pTab_(maxSiz),
          level_(0)
        { }
      
      ~BuffTableStorage() { ASSERT (0==level_, "buffer management logic broken."); }
      
    protected:
      
      friend class BuffTableChunk;
      
      FeedManifold::Chunk
      claim (uint slots)
        {
          ASSERT (pTab_.size() == hTab_.size());
          REQUIRE (level_+slots <= hTab_.size());
          
          size_t prev_level (level_);
          level_ += slots;
          return std::make_pair (&hTab_[prev_level],
                                 &pTab_[prev_level]);
        }
      
      void
      release (uint slots)
        {
          ASSERT (slots <= level_);
          REQUIRE (level_ <= hTab_.size());
          REQUIRE (level_ <= pTab_.size());
          
          level_ -= slots;
        }
      
      bool
      level_check (FeedManifold::Chunk& prev_level)
        {
          return prev_level.first  == &hTab_[level_]
              && prev_level.second == &pTab_[level_];
        }
    };
  
  
  class BuffTableChunk
    : public FeedManifold,
      util::NonCopyable
    {
      const uint siz_;
      FeedManifold::Chunk tab_;
      BuffTableStorage& sto_;
      
    public:
      BuffTableChunk (Connectivity const& wd, BuffTableStorage& storage)
        : siz_(wd.nrI + wd.nrO),
          tab_(storage.claim (siz_)),
          sto_(storage)
        {
          const uint nrO(wd.nrO);
          
          // Setup the publicly visible table locations
          this->outHandle = &tab_.first[ 0 ];
          this->inHandle  = &tab_.first[nrO];
          this->outBuff   = &tab_.second[ 0 ];
          this->inBuff    = &tab_.second[nrO];
        }
      
      ~BuffTableChunk ()
        {
          sto_.release (siz_);
          ASSERT ( sto_.level_check (tab_),
                  "buffer management logic broken.");
        }
    };
  
  
  
  
  
}} // namespace steam::engine
#endif /*ENGINE_FEED_MANIFOLD_OBSOLETE_H*/