feed.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_PROCESSING_FEED_HPP__
#define SHORE_PROCESSING_FEED_HPP__

#include <boost/bind.hpp>

#include "signalslot.hpp"

namespace shore {

template<typename T>
class feed
{
 public:

        typedef T current_type;
        typedef T append_type;

 private:

        typedef feed this_type;

        signal<const current_type&> m_sigdata;
        signal<void> m_sigflush;

        slot<void> m_slotfreeze;
        slot<void> m_slotthaw;

        bool m_frozen;


        void freeze()
        {
                m_frozen=true;
        }

        void thaw()
        {
                m_frozen=false;
        }

 public:

        feed()
        :m_slotfreeze(boost::bind(&this_type::freeze,this)),
         m_slotthaw(boost::bind(&this_type::thaw,this)),
         m_frozen(false)
        {}

        feed(const feed& t)
        :m_slotfreeze(boost::bind(&this_type::freeze,this)),
         m_slotthaw(boost::bind(&this_type::thaw,this)),
         m_frozen(t.m_frozen)
        {
                m_slotfreeze.copy_connections(t.m_slotfreeze);
                m_slotthaw.copy_connections(t.m_slotthaw);
        }

        signal<const current_type&>& sigdata()
        {
                return m_sigdata;
        }

        signal<void>& sigflush()
        {
                return m_sigflush;
        }
        
        void append(const append_type &d)
        {
                if(m_frozen)
                        throw std::logic_error("append to frozen feed");
                m_sigdata.emit(d);
        }

        void flush()
        {
                if(m_frozen)
                        throw std::logic_error("flush frozen feed");
                m_sigflush.emit();
        }

        slot<void>& slotfreeze()
        {
                return m_slotfreeze;
        }

        slot<void>& slotthaw()
        {
                return m_slotthaw;
        }
};

} //namespace shore

#endif // SHORE_PROCESSING_FEED_HPP__