platform/include/pion/platform/PlatformPlugin.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_PLATFORMPLUGIN_HEADER__
#define __PION_PLATFORMPLUGIN_HEADER__

#include <string>
#include <libxml/tree.h>
#include <boost/noncopyable.hpp>
#include <pion/PionConfig.hpp>

namespace pion {        // begin namespace pion
namespace server {      // begin namespace server (Pion Server)

// forward declarations
class ServiceManager;

}   // end namespace server
}   // end namespace pion

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

// forward declarations
class Vocabulary;
class CodecFactory;
class DatabaseManager;
class ReactionEngine;   
class ProtocolFactory;

class PION_PLATFORM_API PlatformPlugin
    : private boost::noncopyable
{
public:

    PlatformPlugin(void) :
        m_codec_factory_ptr(NULL), m_database_mgr_ptr(NULL),
        m_reaction_engine_ptr(NULL), m_protocol_factory_ptr(NULL), m_service_mgr_ptr(NULL)
    {}
    
    virtual ~PlatformPlugin() {}
    
    virtual void setConfig(const Vocabulary& v, const xmlNodePtr config_ptr);

    virtual void updateVocabulary(const Vocabulary& v);

    
    inline void setId(const std::string& plugin_id) { m_plugin_id = plugin_id; }
    
    inline const std::string& getId(void) const { return m_plugin_id; }
    
    inline void setName(const std::string& plugin_name) { m_plugin_name = plugin_name; }
    
    inline const std::string& getName(void) const { return m_plugin_name; }
    
    inline void setComment(const std::string& plugin_comment) { m_plugin_comment = plugin_comment; }
    
    inline const std::string& getComment(void) const { return m_plugin_comment; }

    inline void setCodecFactory(CodecFactory& factory) { m_codec_factory_ptr = & factory; }
    
    inline void setDatabaseManager(DatabaseManager& mgr) { m_database_mgr_ptr = & mgr; }
    
    inline void setReactionEngine(ReactionEngine& engine) { m_reaction_engine_ptr = & engine; }

    inline void setProtocolFactory(ProtocolFactory& factory) { m_protocol_factory_ptr = & factory; }

    inline void setServiceManager(pion::server::ServiceManager& mgr) { m_service_mgr_ptr = & mgr; }

protected:
    
    inline void copyPlugin(const PlatformPlugin& pp) {
        m_plugin_id = pp.m_plugin_id;
        m_plugin_name = pp.m_plugin_name;
        m_plugin_comment = pp.m_plugin_comment;
    }
    
    inline CodecFactory& getCodecFactory(void) {
        PION_ASSERT(m_codec_factory_ptr != NULL);
        return *m_codec_factory_ptr;
    }
    
    inline DatabaseManager& getDatabaseManager(void) {
        PION_ASSERT(m_database_mgr_ptr != NULL);
        return *m_database_mgr_ptr;
    }
    
    inline ReactionEngine& getReactionEngine(void) {
        PION_ASSERT(m_reaction_engine_ptr != NULL);
        return *m_reaction_engine_ptr;
    }

    inline ProtocolFactory& getProtocolFactory(void) {
        PION_ASSERT(m_protocol_factory_ptr != NULL);
        return *m_protocol_factory_ptr;
    }

    inline pion::server::ServiceManager& getServiceManager(void) {
        PION_ASSERT(m_service_mgr_ptr != NULL);
        return *m_service_mgr_ptr;
    }

private:
    
    static const std::string        NAME_ELEMENT_NAME;
    
    static const std::string        COMMENT_ELEMENT_NAME;


    std::string                     m_plugin_id;

    std::string                     m_plugin_name;

    std::string                     m_plugin_comment;
    
    CodecFactory *                  m_codec_factory_ptr;
    
    DatabaseManager *               m_database_mgr_ptr;
    
    ReactionEngine *                m_reaction_engine_ptr;

    ProtocolFactory *               m_protocol_factory_ptr;

    pion::server::ServiceManager *  m_service_mgr_ptr;
};

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

#endif

---