output-slot-connection.hpp

Go to the documentation of this file.

/*
  OUTPUT-SLOT-CONNECTION.hpp  -  implementation API for concrete output slots

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


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "steam/play/output-slot.hpp"
#include "lib/scoped-collection.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/iter-source.hpp"
#include "lib/handle.hpp"
//#include "lib/time/timevalue.hpp"
//#include "steam/engine/buffer-provider.hpp"
//#include "steam/play/timings.hpp"
//#include "lib/sync.hpp"

//#include <string>
#include <functional>
#include <vector>
//#include <memory>


namespace steam {
namespace play {

  using steam::engine::BuffHandle;
//using steam::engine::BufferProvider;
//using lib::time::Time;
//using std::string;
  using lib::iter_stl::eachElm;
  
//using std::placeholders::_1;
//using std::bind;
  using std::vector;
//using std::shared_ptr;
  
  
  
  
  class OutputSlot::Connection
    {
    public:
      virtual ~Connection();
      
      virtual BuffHandle claimBufferFor(FrameID)  =0;
      virtual bool isTimely (FrameID, TimeValue)  =0;
      virtual void transfer (BuffHandle const&)   =0;
      virtual void pushout  (BuffHandle const&)   =0;
      virtual void discard  (BuffHandle const&)   =0;
      virtual void shutDown ()                    =0;
    };
  
  
  
  class OutputSlot::ConnectionState
    : public OutputSlot::Allocation
    , util::NonCopyable
    {
    public:
      virtual ~ConnectionState() { }
      
      virtual Connection& access (uint)  const    =0;
    };
  
  
  
  
  /* ===== Building blocks for OutputSlot implementation ===== */
  
  class OutputSlotImplBase
    : public OutputSlot
    {
    protected:
      template<class CON>
      class ConnectionManager;
    };
  
  
  template<class CON>
  class OutputSlotImplBase::ConnectionManager
    : public OutputSlot::ConnectionState
    {
      typedef lib::ScopedCollection<CON> Connections;
      typedef OutputSlot::OpenedSinks OpenedSinks;
      
      Connections connections_;
      
      
      /* == Allocation Interface == */
      
      OpenedSinks
      getOpenedSinks()
        {
          REQUIRE (this->isActive());
          return lib::iter_source::transform (eachElm(connections_), connectOutputSink);
        }
      
      Timings
      getTimingConstraints()
        {
          UNIMPLEMENTED ("find out about timing constraints");                   
        }
      
      bool
      isActive()  const
        {
          return 0 < connections_.size();
        }
      
      CON&
      access (uint chanNr)  const
        {
          return connections_[chanNr];
        }
      
      
    protected: /* == API for OutputSlot-Impl == */
      void
      init() 
        {
          connections_.populate_by (&ConnectionManager::buildConnection, this);
        }
      
      typedef typename Connections::ElementHolder& ConnectionStorage;
      
      virtual void buildConnection(ConnectionStorage)  =0;
      
      
      ConnectionManager(uint numChannels)
        : connections_(numChannels)
        { }
      
    public:
      virtual
     ~ConnectionManager()
        { }
      
      
      
    private: // Implementation details
      
      static DataSink
      connectOutputSink (CON& connection)
        {
          TRACE (test, "activating Con=%p", &connection );
          
          DataSink newSink;
          newSink.activate(&connection, shutdownConnection);
          return newSink;
        }
      
      static void
      shutdownConnection (OutputSlot::Connection* toClose)
        {
          REQUIRE (toClose);
          toClose->shutDown();
        }
    };
  
  
  
  
}} // namespace steam::play
#endif