platform/include/pion/platform/Protocol.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_PROTOCOL_HEADER__
#define __PION_PROTOCOL_HEADER__

#include <istream>
#include <ostream>
#include <libxml/tree.h>
#include <boost/shared_ptr.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/system/error_code.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 Protocol
    : public PlatformPlugin
{
public:

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

    class UnknownTermException : public PionException {
    public:
        UnknownTermException(const std::string& term)
            : PionException("Protocol configuration references an unknown term: ", term) {}
    };

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

    Protocol(void) {}
    
    virtual ~Protocol() {}
        
    virtual void reset(void) = 0;
    
    virtual boost::shared_ptr<Protocol> clone(void) const = 0;

    virtual bool close(pion::platform::EventPtr& event_ptr_ref,
        bool client_reset, bool server_reset) = 0;

    virtual boost::tribool readNext(bool request, const char* ptr, size_t len, 
            boost::posix_time::ptime data_timestamp, boost::posix_time::ptime ack_timestamp,
            pion::platform::EventContainer& events, boost::system::error_code& ec) = 0;

    virtual bool checkRecoveryPacket(bool request, const char* ptr, size_t len);

    virtual void setConfig(const Vocabulary& v, const xmlNodePtr config_ptr);
    
    virtual void updateVocabulary(const Vocabulary& v);
    
    inline Event::EventType getEventType(void) const { return m_event_term.term_ref; }

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

    EventFactory                    m_event_factory;


private:
    
    static const std::string        EVENT_ELEMENT_NAME;

    
    Vocabulary::Term                m_event_term;
};


typedef boost::shared_ptr<Protocol> ProtocolPtr;

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

#endif

---