extractor.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_EXTRACTOR_HPP__
#define SHORE_PROCESSING_EXTRACTOR_HPP__


#include "signalslot.hpp"
#include "pipeline.hpp"

namespace shore {

template<typename T>
class extractor
{
 private:

        class rawsink
        {
         private:

                friend class extractor;

                sink<rawsink,T>* m_sink;
                const T* m_data;

         public:
                
                typedef T append_type;

                rawsink()
                :m_data(0)
                {}

                void append(const T& v)
                {
                        if(m_data!=0)
                                throw std::logic_error("extractor: suffocated");
                        m_data=&v;
                        m_sink->sigfreeze().emit();
                }

                void flush()
                {}
        };

        sink<rawsink,T> m_sink;

 public:

        typedef T append_type;
        typedef T current_type;

        extractor()
        {
                m_sink->m_sink=&m_sink;
        }

        const T& current() const
        {
                return *(m_sink->m_data);
        }

        bool has_data()
        {
                if((m_sink->m_data)==0)
                        m_sink.sigthaw().emit();
                return (m_sink->m_data)!=0;
        }

        void next()
        {
                (m_sink->m_data)=0;
                m_sink.sigthaw().emit();
        }

        slot<const append_type&>& slotdata()
        {
                return m_sink.slotdata();
        }

        slot<void>& slotflush()
        {
                return m_sink.slotflush();
        }

        signal<void>& sigfreeze()
        {
                return m_sink.sigfreeze();
        }

        signal<void>& sigthaw()
        {
                return m_sink.sigthaw();
        }
};

} //namespace shore

#endif // SHORE_PROCESSING_EXTRACTOR_HPP__