platform/include/pion/platform/VocabularyConfig.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_VOCABULARYCONFIG_HEADER__
#define __PION_VOCABULARYCONFIG_HEADER__

#include <string>
#include <libxml/tree.h>
#include <boost/bind.hpp>
#include <boost/signal.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PionHashMap.hpp>
#include <pion/platform/Vocabulary.hpp>
#include <pion/platform/ConfigManager.hpp>


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


class PION_PLATFORM_API VocabularyConfig :
    public ConfigManager
{
public:

    class VocabularyIsLockedException : public PionException {
    public:
        VocabularyIsLockedException(const std::string& vocab_id)
            : PionException("Unable to modify a locked Vocabulary: ", vocab_id) {}
    };

    class MissingVocabularyException : public PionException {
    public:
        MissingVocabularyException(const std::string& config_file)
            : PionException("Configuration file does not define a Vocabulary: ", config_file) {}
    };
    
    class UpdateVocabularyException : public PionException {
    public:
        UpdateVocabularyException(const std::string& config_file)
            : PionException("Unable to update Vocabulary configuration file: ", config_file) {}
    };
    
    class EmptyVocabularyIdException : public PionException {
    public:
        EmptyVocabularyIdException(const std::string& config_file)
            : PionException("Vocabulary configuration file does not define a unique identifier: ", config_file) {}
    };
    
    class EmptyTypeException : public PionException {
    public:
        EmptyTypeException(const std::string& term_id)
            : PionException("Vocabulary configuration has an empty data type for Term: ", term_id) {}
    };
    
    class InitializeConfigException : public PionException {
    public:
        InitializeConfigException(const std::string& file_name)
            : PionException("Unable to initialize Vocabulary configuration file: ", file_name) {}
    };
    
    class AddTermConfigException : public PionException {
    public:
        AddTermConfigException(const std::string& term_id)
            : PionException("Unable to add a Term to the Vocabulary configuration file: ", term_id) {}
    };

    class RemoveTermConfigException : public PionException {
    public:
        RemoveTermConfigException(const std::string& term_id)
            : PionException("Unable to remove a Term from the Vocabulary configuration file: ", term_id) {}
    };

    class UpdateTermConfigException : public PionException {
    public:
        UpdateTermConfigException(const std::string& term_id)
            : PionException("Unable to update Term in the Vocabulary configuration file: ", term_id) {}
    };
    
    
    VocabularyConfig(void);
    
    virtual ~VocabularyConfig() {}
    
    virtual void createConfigFile(void);
    
    virtual void openConfigFile(void);
    
    void setId(const std::string& new_id);
    
    void setName(const std::string& new_name);
    
    void setComment(const std::string& new_comment);

    void setLocked(bool b);
    
    void setConfig(const xmlNodePtr config_ptr);
    
    void addTerm(const Vocabulary::Term& new_term);
    
    inline void addTerm(const std::string& term_id, const xmlNodePtr config_ptr) {
        Vocabulary::Term new_term(term_id);
        parseTermConfig(new_term, config_ptr);
        addTerm(new_term);
    }

    void updateTerm(const Vocabulary::Term& t);

    inline void updateTerm(const std::string& term_id, const xmlNodePtr config_ptr) {
        Vocabulary::Term updated_term(term_id);
        parseTermConfig(updated_term, config_ptr);
        updateTerm(updated_term);
    }
    
    void removeTerm(const std::string& term_id);
    
    inline void bind(Vocabulary& v) {
        m_signal_add_term.connect(boost::bind(&Vocabulary::addTerm, &v, _1));
        m_signal_update_term.connect(boost::bind(&Vocabulary::updateTerm, &v, _1));
        m_signal_remove_term.connect(boost::bind(&Vocabulary::removeTerm, &v, _1));
        v += m_vocabulary;
    }

    inline const std::string& getId(void) const { return m_vocabulary_id; }
    
    inline const std::string& getName(void) const { return m_name; }
    
    inline const std::string& getComment(void) const { return m_comment; }
    
    inline bool getLocked(void) const { return m_is_locked; }
    
    inline const Vocabulary& getVocabulary(void) const { return m_vocabulary; }

    static inline const std::string& getVocabularyElementName(void) {
        return VOCABULARY_ELEMENT_NAME;
    }
    
    static xmlNodePtr createVocabularyConfig(const char *buf, std::size_t len) {
        return ConfigManager::createResourceConfig(VOCABULARY_ELEMENT_NAME, buf, len);
    }
    
    static xmlNodePtr createTermConfig(const char *buf, std::size_t len) {
        return ConfigManager::createResourceConfig(TERM_ELEMENT_NAME, buf, len);
    }
    
    static void writeTermConfigXML(std::ostream& out, const Vocabulary::Term& t);

    static void parseTermConfig(Vocabulary::Term& new_term,
                                const xmlNodePtr config_ptr);
    
    
private:

    bool addNewTermTypeConfig(xmlNodePtr term_node, const Vocabulary::Term& t);

    
    static const std::string        DEFAULT_CONFIG_FILE;

    static const std::string        VOCABULARY_ELEMENT_NAME;

    static const std::string        LOCKED_ELEMENT_NAME;
    
    static const std::string        TERM_ELEMENT_NAME;
    
    static const std::string        TYPE_ELEMENT_NAME;

    static const std::string        SIZE_ATTRIBUTE_NAME;    
        
    static const std::string        FORMAT_ATTRIBUTE_NAME;  

    
    xmlNodePtr                      m_vocabulary_node;
    
    Vocabulary                      m_vocabulary;
    
    std::string                     m_vocabulary_id;
    
    std::string                     m_name;
    
    std::string                     m_comment;
    
    bool                            m_is_locked;
    
    boost::signal1<void,const Vocabulary::Term&>                m_signal_add_term;

    boost::signal1<void,const Vocabulary::Term&>                m_signal_update_term;

    boost::signal1<void,const std::string&>                     m_signal_remove_term;
};


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

#endif

---