platform/reactors/FissionReactor.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2009 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Pion is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// Pion 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 Affero General Public License for
// more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Pion.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef __PION_FISSIONREACTOR_HEADER__
#define __PION_FISSIONREACTOR_HEADER__

#include <string>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Codec.hpp>
#include <pion/platform/Reactor.hpp>
#include <pion/platform/Vocabulary.hpp>


namespace pion {        // begin namespace pion
namespace plugins {     // begin namespace plugins


class FissionReactor :
    public pion::platform::Reactor
{
public: 
    
    class UnknownTermException : public PionException {
    public:
        UnknownTermException(const std::string& term_id)
            : PionException("FissionReactor configuration references an unknown term: ", term_id) {}
    };

    class NotAnObjectException : public PionException {
    public:
        NotAnObjectException(const std::string& event_type)
            : PionException("FissionReactor configuration defines a non-object input event type: ", event_type) {}
    };

    class TermNotStringException : public PionException {
    public:
        TermNotStringException(const std::string& term_id)
            : PionException("FissionReactor non-string input event term specified: ", term_id) {}
    };

    class EmptyCodecException : public PionException {
    public:
        EmptyCodecException(const std::string& reactor_id)
            : PionException("FissionReactor configuration is missing a required Codec parameter: ", reactor_id) {}
    };

    class EmptyInputEventTypeException : public PionException {
    public:
        EmptyInputEventTypeException(const std::string& reactor_id)
            : PionException("FissionReactor configuration is missing a required InputEventType parameter: ", reactor_id) {}
    };

    class EmptyInputEventTermException : public PionException {
    public:
        EmptyInputEventTermException(const std::string& reactor_id)
            : PionException("FissionReactor configuration is missing a required InputEventTerm parameter: ", reactor_id) {}
    };


    FissionReactor(void)
        : Reactor(TYPE_PROCESSING), m_copy_all_terms(false),
        m_input_event_type(""), m_input_event_term("")
    {}
    
    virtual ~FissionReactor() { stop(); }
    
    virtual void setConfig(const pion::platform::Vocabulary& v, const xmlNodePtr config_ptr);
    
    virtual void updateVocabulary(const pion::platform::Vocabulary& v);

    virtual void updateCodecs(void);

    virtual void process(const pion::platform::EventPtr& e);
    
    
private:

    typedef std::vector<pion::platform::Vocabulary::Term>   TermVector;


    static const std::string            COPY_TERM_ELEMENT_NAME;

    static const std::string            COPY_ALL_TERMS_ELEMENT_NAME;

    static const std::string            INPUT_EVENT_TYPE_ELEMENT_NAME;

    static const std::string            INPUT_EVENT_TERM_ELEMENT_NAME;

    static const std::string            CODEC_ELEMENT_NAME;


    bool                                m_copy_all_terms;

    TermVector                          m_copy_terms;

    pion::platform::Vocabulary::Term    m_input_event_type;

    pion::platform::Vocabulary::Term    m_input_event_term;

    pion::platform::CodecPtr            m_codec_ptr;

    std::string                         m_codec_id;

    boost::mutex                        m_codec_mutex;
};


}   // end namespace plugins
}   // end namespace pion

#endif

---