buffer_chain.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_BUFFER_CHAIN_HPP__
#define SHORE_PROCESSING_BUFFER_CHAIN_HPP__

#include <deque>
#include <string>

#include "shore/base/util.hpp"
#include "shore/processing/plugin.hpp"

namespace shore {

template<typename T>
class  buffer_chain
{
 public:

        typedef plugin<T> plugin_type;

 private:

        std::deque<T *> m_buffers;

        std::vector<T *> m_unused;

        std::vector<plugin_type *> m_plugins;

        size_t m_next_plugin;

        bool m_ready;

        bool m_flushed;


        bool apply_plugins()
        {
                while(m_next_plugin<m_plugins.size())
                {
                        const int result=
                                m_plugins[m_next_plugin]->apply(m_buffers,
                                                                m_unused,
                                                                m_flushed);

                        if(result&plugin_type::PLUGIN_STARVED)
                        {
                                if(result&plugin_type::PLUGIN_END)
                                        m_next_plugin=0;

                                return false;
                        }

                        if(result&plugin_type::PLUGIN_END)
                                m_next_plugin=0;
                        else
                                ++m_next_plugin;
                }

                m_next_plugin=0;

                return !m_buffers.empty();
        }

 protected:

        bool buffer_chain_ready() const
        {
                return m_ready;
        }

        T & buffer_chain_push()
        {
                if(!buffer_chain_waiting())
                        throw_exception(std::logic_error("buffer_chain_push()"
                                                         " not allowed here"));

                if(m_unused.empty())
                        m_buffers.push_back(new T);
                else
                {
                        m_buffers.push_back(m_unused.back());
                        m_unused.pop_back();
                }

                return *(m_buffers.back());
        }

        bool buffer_chain_prepare()
        {
                if(!buffer_chain_waiting())
                        throw_exception(std::logic_error("buffer_chain_prepare()"
                                                         " not allowed here"));

                m_ready=apply_plugins();

                return m_ready;
        }

        bool buffer_chain_flush(const bool undo_last_push)
        {
                if(!buffer_chain_waiting())
                        throw_exception(std::logic_error("buffer_chain_flush()"
                                                         " not allowed here"));

                if(undo_last_push&&(!m_buffers.empty()))
                {
                        m_unused.push_back(m_buffers.back());
                        m_buffers.pop_back();
                }

                m_flushed=true;

                m_ready=apply_plugins();

                return m_ready;
        }

        const T & buffer_chain_front() const
        {
                return *m_buffers.front();
        }

        bool buffer_chain_waiting() const
        {
                return !(m_ready||m_flushed);
        }

        bool buffer_chain_pop()
        {
                m_unused.push_back(m_buffers.front());
                m_buffers.pop_front();

                m_ready=apply_plugins();

                return m_ready;
        }

        void buffer_chain_reset()
        {
                while(!m_buffers.empty())
                {
                        m_unused.push_back(m_buffers.back());
                        m_buffers.pop_back();
                }
                m_ready=m_flushed=false;
        }

        T * buffer_chain_swap(T * buf)
        {
                T *const ret=m_buffers.back();
                m_buffers.back()=buf;
                return ret;
        }

 public:

        buffer_chain()
        :m_next_plugin(0),
         m_ready(false),
         m_flushed(false)
        {}

        ~buffer_chain()
        {
                buffer_chain_reset();

                while(!m_unused.empty())
                {
                        delete m_unused.back();
                        m_unused.pop_back();
                }
        }

        void add_plugin(plugin_type *const p)
        {
                m_plugins.push_back(p);
        }

        void clear_plugins()
        {
                m_plugins.clear();
        }
};

} //namespace shore

#endif // SHORE_PROCESSING_BUFFER_CHAIN_HPP__