platform/include/pion/platform/Codec.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2008 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_CODEC_HEADER__
#define __PION_CODEC_HEADER__

#include <istream>
#include <ostream>
#include <libxml/tree.h>
#include <boost/shared_ptr.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Event.hpp>
#include <pion/platform/Vocabulary.hpp>
#include <pion/platform/PlatformPlugin.hpp>


namespace pion {        // begin namespace pion
namespace platform {    // begin namespace platform (Pion Platform Library)


class PION_PLATFORM_API Codec
    : public PlatformPlugin
{
public:

    class EmptyEventException : public PionException {
    public:
        EmptyEventException(const std::string& codec_id)
            : PionException("Codec configuration does not define an event type: ", codec_id) {}
    };

    class UnknownTermException : public PionException {
    public:
        UnknownTermException(const std::string& event_type)
            : PionException("Codec configuration references an unknown event type: ", event_type) {}
    };

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

    class WrongEventTypeException : public PionException {
    public:
        WrongEventTypeException(void)
            : PionException("Event is not of the expected type") {}
    };

    Codec(void) {}
    
    virtual ~Codec() {}
    
    virtual const std::string& getContentType(void) const = 0;
    
    virtual boost::shared_ptr<Codec> clone(void) const = 0;

    virtual void write(std::ostream& out, const Event& e) = 0;

    virtual void finish(std::ostream& out) = 0;

    virtual bool read(std::istream& in, Event& e) = 0;

    virtual void setConfig(const Vocabulary& v, const xmlNodePtr config_ptr);
    
    virtual void updateVocabulary(const Vocabulary& v);

    inline EventPtr read(std::istream& in, EventFactory& f) {
        EventPtr event_ptr(f.create(getEventType()));
        if (! read(in, *event_ptr))
            event_ptr.reset();
        return event_ptr;
    }
    
    inline Event::EventType getEventType(void) const { return m_event_term.term_ref; }

    
protected:
    
    inline void copyCodec(const Codec& c) {
        copyPlugin(c);
        m_event_term = c.m_event_term;
    }

    
private:
    
    static const std::string        EVENT_ELEMENT_NAME;

    
    Vocabulary::Term                m_event_term;
};


typedef boost::shared_ptr<Codec>    CodecPtr;
    
    
//
// The following symbols must be defined for any Codecs that you would
// like to be able to load dynamically using the CodecFactory::loadCodec()
// function.  These are not required for any Codecs that you only want to link
// directly into your programs.
//
// Make sure that you replace "CODEC" with the name of your derived class.
// This name must also match the name of the object file (excluding the
// extension).  These symbols must be linked into your Codec's object file,
// not included in any headers that it may use (declarations are OK in headers
// but not the definitions).
//
// The "pion_create" function is used to create new instances of your Codec.
// The "pion_destroy" function is used to destroy instances of your Codec.
//
// extern "C" PION_PLUGIN_API Codec *pion_create_CODEC(void) {
//      return new CODEC;
// }
//
// extern "C" PION_PLUGIN_API void pion_destroy_CODEC(CODEC *codec_ptr) {
//      delete codec_ptr;
// }
//

    
}   // end namespace platform
}   // end namespace pion

#endif

---