plugin.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_PLUGIN_HPP__
#define SHORE_PROCESSING_PLUGIN_HPP__

#include <deque>
#include <stdexcept>
#include <string>

namespace shore {

template<typename T>
class plugin
{
 public:

        virtual ~plugin() {}

        enum PluginResult
        {
                PLUGIN_SUCCESS=0,
                PLUGIN_STARVED=1,
                PLUGIN_END=2
        };

        virtual int apply(std::deque<T *> & buffers,
                          std::vector<T *> & unused,
                          const bool flush)=0;
};

template<typename Cmp>
bool is_valid_comparator(const Cmp &cmp,
                         typename boost::disable_if<boost::is_pointer<Cmp> >::type * =0)
{
        return true;
}

template<typename Cmp>
bool is_valid_comparator(const Cmp &cmp,
                         typename boost::enable_if<boost::is_pointer<Cmp> >::type * =0)
{
        return (cmp!=0);
}

template<typename T,
         typename Cmp=bool (*)(const T &,const T &)>
class sorting_check
:public plugin<T>
{
 public:

        typedef plugin<T> plugin_type;

        struct error
        :public std::runtime_error
        {
                error()
                :std::runtime_error("sorting_check: not sorted appropriately")
                {}

                error(const std::string &name)
                :std::runtime_error("sorting_check: \""+name+"\" is"
                                    " not sorted appropriately")
                {}
        };

 private:

        Cmp m_cmp;

        error m_error;

 public:

        sorting_check(Cmp cmp=Cmp())
        :m_cmp(cmp)
        {}

        sorting_check(const std::string &name,Cmp cmp=Cmp())
        :m_cmp(cmp),
         m_error(name)
        {}

        virtual int apply(std::deque<T *> & buffers,
                          std::vector<T *> & unused,
                          const bool flush)
        {
                if(!is_valid_comparator(m_cmp))
                        return plugin_type::PLUGIN_SUCCESS;

                if(buffers.size()<2)
                        return flush?(plugin_type::PLUGIN_SUCCESS)
                                    :(plugin_type::PLUGIN_STARVED);

                if(m_cmp(*(buffers[1]),*(buffers.front())))
                        throw m_error;

                return plugin_type::PLUGIN_SUCCESS;
        }

        Cmp get_comparator() const
        {
                return m_cmp;
        }
};

} //namespace shore

#endif // SHORE_PROCESSING_PLUGIN_HPP__