monolithic_source.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_MONOLITHIC_SOURCE_HPP__
#define SHORE_PROCESSING_MONOLITHIC_SOURCE_HPP__

#include <stdexcept>
#include <boost/utility/enable_if.hpp>

#include "shore/processing/method_check.hpp"
#include "shore/processing/pipeline.hpp"
#include "shore/processing/buffer_chain.hpp"
#include "shore/processing/plugin.hpp"
#include "shore/base/stringops.hpp"

namespace shore {

template<typename S,
         typename T=typename source_traits<S>::current_type,
         typename Cmp=bool (*)(const T &,const T &)>
class monolithic
:public buffer_chain<T>
{
 public:

        typedef S source_type;
        typedef T current_type;
        typedef Cmp compare_type;

 private:

        source_type m_basic;

        sorting_check<T,Cmp> m_check;


        template<typename _S>
        static std::string get_name(_S &b,
                                    typename boost::enable_if<shore::has_get_name<_S> >::type * =0)
        {
                return b.get_name();
        }

        template<typename _S>
        static std::string get_name(_S &b,
                                    typename boost::disable_if<shore::has_get_name<_S> >::type * =0)
        {
                return "<unnamed source "+shore::to_string(&b)+">";
        }

        void get_source_data()
        {
                if(buffer_chain<T>::buffer_chain_waiting())
                {
                        while(m_basic.next(buffer_chain<T>::buffer_chain_push()))
                                if(buffer_chain<T>::buffer_chain_prepare())
                                        return;

                        // No more data, flush.
                        // The last buffer pushed could not be initialized, so
                        buffer_chain<T>::buffer_chain_flush(true);
                }
        }

 protected:

        Cmp get_comparator() const
        {
                return m_check.get_comparator();
        }

 public:

        monolithic(Cmp cmp=Cmp())
        :m_check(get_name(m_basic),cmp)
        {
                if(is_valid_comparator(cmp))
                        add_plugin(&m_check);
        }

        template<typename Arg>
        monolithic(Arg a1,Cmp cmp=Cmp())
        :m_basic(a1),
         m_check(get_name(m_basic),cmp)
        {
                if(is_valid_comparator(cmp))
                        add_plugin(&m_check);
        }

        template<typename Arg1,typename Arg2>
        monolithic(Arg1 a1,Arg2 a2,Cmp cmp=Cmp())
        :m_basic(a1,a2),
         m_check(get_name(m_basic),cmp)
        {
                if(is_valid_comparator(cmp))
                        add_plugin(&m_check);
        }

        source_type &basic()
        {
                return m_basic;
        }

        const source_type &basic() const
        {
                return m_basic;
        }

        const current_type &current() const
        {
                return buffer_chain<T>::buffer_chain_front();
        }

        bool has_data()
        {
                get_source_data();
                return buffer_chain<T>::buffer_chain_ready();
        }

        void next()
        {
                buffer_chain<T>::buffer_chain_pop();
                get_source_data();
        }
};

} //namespace shore

#endif // SHORE_PROCESSING_MONOLITHIC_SOURCE_HPP__