platform/codecs/XMLCodec.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_XMLCODEC_HEADER__
#define __PION_XMLCODEC_HEADER__

#include <vector>
#include <map>
#include <queue>
#include <libxml/tree.h>
#include <libxml/xmlwriter.h>
#include <libxml/xmlreader.h>
#include <pion/PionConfig.hpp>
#include <pion/platform/Codec.hpp>


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


class XMLCodec :
    public pion::platform::Codec
{
public:
    class EmptyFieldException : public PionException {
    public:
        EmptyFieldException(const std::string& codec_id)
            : PionException("XMLCodec configuration includes an empty field name: ", codec_id) {}
    };

    class EmptyTermException : public PionException {
    public:
        EmptyTermException(const std::string& codec_id)
            : PionException("XMLCodec configuration is missing a term identifier: ", codec_id) {}
    };


    XMLCodec(void) :
        pion::platform::Codec(),
        m_flush_after_write(false), m_xml_writer(NULL), m_buf(NULL), m_xml_reader(NULL),
        m_no_events_written(true), m_first_read_attempt(true)
    {}
    
    virtual ~XMLCodec() {
        if (m_xml_reader)
            xmlFreeTextReader(m_xml_reader);
        if (m_xml_writer)
            xmlFreeTextWriter(m_xml_writer);
        if (m_buf)
            xmlBufferFree(m_buf);
    }
    
    virtual const std::string& getContentType(void) const { return CONTENT_TYPE; }

    virtual pion::platform::CodecPtr clone(void) const;

    virtual void write(std::ostream& out, const pion::platform::Event& e);

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

    virtual bool read(std::istream& in, pion::platform::Event& e);

    virtual void setConfig(const pion::platform::Vocabulary& v, const xmlNodePtr config_ptr);

    virtual void updateVocabulary(const pion::platform::Vocabulary& v);

    inline void reset(void) {
        m_field_map.clear();
        m_format.clear();
    }
    
    struct XMLField {
        XMLField(const std::string& f, const pion::platform::Vocabulary::Term& t)
            : field_name(f), term(t)
        {}

        std::string                         field_name;

        pion::platform::Vocabulary::Term    term;

        PionTimeFacet                       time_facet;
    };

    typedef boost::shared_ptr<XMLField>     XMLFieldPtr;

    typedef PION_HASH_MAP<std::string,
        XMLFieldPtr,
        PION_HASH_STRING>                   FieldMap;

    typedef std::vector<XMLFieldPtr>        CurrentFormat;

private:

    typedef std::istream::traits_type       traits_type;

    typedef std::basic_streambuf<
        std::istream::char_type,
        std::istream::traits_type>          streambuf_type;

    inline void mapFieldToTerm(const std::string& field,
                               const pion::platform::Vocabulary::Term& term);

    // Callback for xmlReaderForIO() to read more data.
    static int  xmlInputReadCallback(void* context, char* buffer, int len);

    // Callback for xmlReaderForIO(), called when it's done reading.
    static int  xmlInputCloseCallback(void* context);


    static const std::string        CONTENT_TYPE;

    static const std::string        FIELD_ELEMENT_NAME;

    static const std::string        TERM_ATTRIBUTE_NAME;

    static const std::string        EVENT_TAG_ELEMENT_NAME;

    static const std::string        DEFAULT_EVENT_TAG;

    static const std::string        EVENT_CONTAINER_TAG_ELEMENT_NAME;

    static const std::string        DEFAULT_EVENT_CONTAINER_TAG;


    std::string                     m_event_tag;

    std::string                     m_event_container_tag;

    FieldMap                        m_field_map;

    std::map<pion::platform::Vocabulary::TermRef, XMLFieldPtr>
                                    m_XML_field_ptr_map;

    CurrentFormat                   m_format;

    bool                            m_flush_after_write;

    xmlTextWriterPtr                m_xml_writer;

    xmlBufferPtr                    m_buf;

    xmlTextReaderPtr                m_xml_reader;

    bool                            m_no_events_written;

    bool                            m_first_read_attempt;
};


// inline member functions for XMLCodec

inline void XMLCodec::mapFieldToTerm(const std::string& field,
                                      const pion::platform::Vocabulary::Term& term)
{
    if (m_field_map[field])
        throw PionException("Duplicate Field Name");

    // prepare a new XML field object
    XMLFieldPtr field_ptr(new XMLField(field, term));
    switch (term.term_type) {
        case pion::platform::Vocabulary::TYPE_DATE_TIME:
        case pion::platform::Vocabulary::TYPE_DATE:
        case pion::platform::Vocabulary::TYPE_TIME:
            field_ptr->time_facet.setFormat(term.term_format);
            break;
        default:
            break; // do nothing
    }

    // add it to the mapping of field names
    m_field_map[field] = field_ptr;

    // append the new field to the current format
    m_format.push_back(field_ptr);
}

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

#endif

---