platform/include/pion/platform/ProtocolFactory.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_PROTOCOLFACTORY_HEADER__
#define __PION_PROTOCOLFACTORY_HEADER__

#include <string>
#include <libxml/tree.h>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Protocol.hpp>
#include <pion/platform/PluginConfig.hpp>


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

class PION_PLATFORM_API ProtocolFactory :
    public PluginConfig<Protocol>
{
public:

    class ProtocolNotFoundException : public PionException {
    public:
        ProtocolNotFoundException(const std::string& protocol_id)
            : PionException("No protocol found for identifier: ", protocol_id) {}
    };

    
    virtual ~ProtocolFactory() {}
    
    explicit ProtocolFactory(const VocabularyManager& vocab_mgr);

    ProtocolPtr getProtocol(const std::string& protocol_id);

    void setProtocolConfig(const std::string& protocol_id, const xmlNodePtr config_ptr);

    std::string addProtocol(const xmlNodePtr config_ptr);
    
    void removeProtocol(const std::string& protocol_id);

    static xmlNodePtr createProtocolConfig(const char *buf, std::size_t len) {
        return ConfigManager::createResourceConfig(PROTOCOL_ELEMENT_NAME, buf, len);
    }
    
protected:
    
    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr)
    {
        try {
            Protocol *new_plugin_ptr = m_plugins.load(plugin_id, plugin_name);
            new_plugin_ptr->setId(plugin_id);
            new_plugin_ptr->setProtocolFactory(*this);
            if (config_ptr != NULL) {
                VocabularyPtr vocab_ptr(m_vocab_mgr.getVocabulary());
                new_plugin_ptr->setConfig(*vocab_ptr, config_ptr);
            }
        } catch (PionPlugin::PluginNotFoundException&) {
            throw;
        } catch (std::exception& e) {
            throw PluginException(e.what());
        }
    }

    
private:
    
    static const std::string        DEFAULT_CONFIG_FILE;

    static const std::string        PROTOCOL_ELEMENT_NAME;
};


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

#endif

---