platform/include/pion/platform/CodecFactory.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_CODECFACTORY_HEADER__
#define __PION_CODECFACTORY_HEADER__

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


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

class PION_PLATFORM_API CodecFactory :
    public PluginConfig<Codec>
{
public:

    class CodecNotFoundException : public PionException {
    public:
        CodecNotFoundException(const std::string& codec_id)
            : PionException("No codecs found for identifier: ", codec_id) {}
    };

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

    CodecPtr getCodec(const std::string& codec_id);

    void setCodecConfig(const std::string& codec_id, const xmlNodePtr config_ptr);

    std::string addCodec(const xmlNodePtr config_ptr);
    
    void removeCodec(const std::string& codec_id);

    static xmlNodePtr createCodecConfig(const char *buf, std::size_t len) {
        return ConfigManager::createResourceConfig(CODEC_ELEMENT_NAME, buf, len);
    }

    std::string getPermissionType(void) const { return CODECS_PERMISSION_TYPE; }

protected:
    
    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr)
    {
        try {
            Codec *new_plugin_ptr = m_plugins.load(plugin_id, plugin_name);
            new_plugin_ptr->setId(plugin_id);
            new_plugin_ptr->setCodecFactory(*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        CODEC_ELEMENT_NAME;

    static const std::string        CODECS_PERMISSION_TYPE;
};


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

#endif

---