bufftable.hpp

Go to the documentation of this file.

/*
  BUFFTABLE.hpp  -  Table of buffer pointers to be used by the render nodes

   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_BUFFHTABLE_H
#define ENGINE_BUFFHTABLE_H


#include "lib/error.hpp"
#include "steam/engine/buffhandle.hpp"
#include "steam/engine/proc-node.hpp"
#include "lib/iter-adapter.hpp"

#include <vector>
#include <utility>



namespace steam {
namespace engine {
  
  using std::pair;
  using std::vector;
  
  
  struct BuffTable
    {
      typedef BuffHandle        * PHa;
      typedef BuffHandle::PBuff * PBu;
      
      struct StorageChunk
        { };
      
      template<uint count>
      struct Storage
        {
          enum{size = count * sizeof(StorageChunk)};
        };
      
      class Builder
        {
        public:
          Builder& announce (uint count, BuffDescr const& type);
          BuffTable& build();
        };
      
      static Builder& prepare (const size_t STORAGE_SIZE, void* storage);
      
      void lockBuffers();
      void releaseBuffers();
      
      typedef vector<BuffHandle> BuffHandleTable;
      typedef lib::RangeIter<BuffHandleTable::iterator> iterator;
      
      iterator buffers();
      iterator inBuffers();
      iterator outBuffers();
    };
  
  
  
  
  /* === Implementation === */
  
  inline BuffTable::Builder&
  BuffTable::prepare (const size_t STORAGE_SIZE, void* storage)
  {
    UNIMPLEMENTED ("expose a builder object for outfitting a buffer pointer table");
  }
  
  
  inline BuffTable::Builder&
  BuffTable::Builder::announce (uint count, BuffDescr const& type)
  {
    UNIMPLEMENTED ("accept announcement of additional buffer table entries required");
  }
  
  
  inline BuffTable&
  BuffTable::Builder::build()
  {
    UNIMPLEMENTED ("finally drop off the newly configured buffer pointer table");
  }
  
  
  inline void
  BuffTable::lockBuffers()
  {
    UNIMPLEMENTED ("convenience shortcut: lock all preconfigured buffers within this table through the underlying buffer provider");
  }
  
  
  inline void
  BuffTable::releaseBuffers()
  {
    UNIMPLEMENTED ("convenience shortcut: release all the buffers managed through this buffer table, by forwarding to the underlying buffer provider");
  }
  
  
  
  inline BuffTable::iterator
  BuffTable::buffers()
  {
    UNIMPLEMENTED ("expose an iterator to yield all prepared buffers within this buffer table");
  }
  
  
  inline BuffTable::iterator
  BuffTable::inBuffers()
  {
    UNIMPLEMENTED ("expose an iterator to access all the input buffer slots of this buffer table");
  }
  
  
  inline BuffTable::iterator
  BuffTable::outBuffers()
  {
    UNIMPLEMENTED ("expose an iterator to access all the output buffer slots of this buffer table");
  }



  
  
  
}} // namespace steam::engine
#endif