platform/include/pion/platform/VocabularyManager.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_VOCABULARYMANAGER_HEADER__
#define __PION_VOCABULARYMANAGER_HEADER__

#include <string>
#include <boost/bind.hpp>
#include <boost/signal.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PionHashMap.hpp>
#include <pion/platform/ConfigManager.hpp>
#include <pion/platform/VocabularyConfig.hpp>


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


class PION_PLATFORM_API VocabularyManager
    : public ConfigManager
{
public:
    
    class EmptyVocabularyConfigException : public PionException {
    public:
        EmptyVocabularyConfigException(const std::string& config_file)
            : PionException("Configuration file defines an empty Vocabulary config element: ", config_file) {}
    };

    class MissingVocabularyPathException : public PionException {
    public:
        MissingVocabularyPathException(const std::string& config_file)
            : PionException("Configuration file does not define a Vocabulary path: ", config_file) {}
    };

    class DuplicateVocabularyException : public PionException {
    public:
        DuplicateVocabularyException(const std::string& vocab_id)
            : PionException("Vocabulary has already been loaded: ", vocab_id) {}
    };

    class VocabularyNotFoundException : public PionException {
    public:
        VocabularyNotFoundException(const std::string& vocab_id)
            : PionException("Vocabulary has not been defined: ", vocab_id) {}
    };

    class AddVocabularyConfigException : public PionException {
    public:
        AddVocabularyConfigException(const std::string& vocab_id)
            : PionException("Unable to add a Vocabulary to the configuration file: ", vocab_id) {}
    };

    class RemoveVocabularyConfigException : public PionException {
    public:
        RemoveVocabularyConfigException(const std::string& vocab_id)
            : PionException("Unable to remove a Vocabulary from the configuration file: ", vocab_id) {}
    };
    
    class UpdateVocabularyPathException : public PionException {
    public:
        UpdateVocabularyPathException(const std::string& config_file)
            : PionException("Unable to update Vocabulary path in the configuration file: ", config_file) {}
    };

    
    VocabularyManager(void);
    
    virtual ~VocabularyManager() {}
    
    virtual void createConfigFile(void);
    
    virtual void openConfigFile(void);
    
    virtual void writeConfigXML(std::ostream& out) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        ConfigManager::writeConfigXMLHeader(out);
        ConfigManager::writeConfigXML(out, m_config_node_ptr, true);
    }

    bool writeConfigXML(std::ostream& out, const std::string& vocab_id) const;

    bool writeTermConfigXML(std::ostream& out, const std::string& term_id) const;
    
    void writeTermConfigXML(std::ostream& out) const;

    void addVocabulary(const std::string& vocab_id,
                       const std::string& vocab_name,
                       const std::string& vocab_comment);
    
    void addVocabulary(const std::string& vocab_id, const char *content_buf,
                       std::size_t content_length);

    void removeVocabulary(const std::string& vocab_id);
    
    void setVocabularyPath(const std::string& vocab_path);
    
    void setVocabularyConfig(const std::string& vocab_id,
                             const xmlNodePtr config_ptr)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::setConfig,
                                               _1, config_ptr));
    }
    
    inline void setName(const std::string& vocab_id,
                        const std::string& new_name)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::setName,
                                               _1, boost::cref(new_name)));
    }
    
    inline void setComment(const std::string& vocab_id,
                           const std::string& new_comment)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::setComment,
                                               _1, boost::cref(new_comment)));
    }
    
    inline void setLocked(const std::string& vocab_id, bool locked_setting)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::setLocked,
                                               _1, locked_setting));
    }
    
    inline void addTerm(const std::string& vocab_id,
                        const Vocabulary::Term& new_term)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::addTerm,
                                               _1, boost::cref(new_term)));
    }
    
    inline void addTerm(const std::string& vocab_id,
                        const std::string& term_id,
                        const xmlNodePtr config_ptr)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::addTerm,
                                               _1, boost::cref(term_id), config_ptr));
    }
    
    inline void updateTerm(const std::string& vocab_id,
                           const Vocabulary::Term& t)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::updateTerm,
                                               _1, boost::cref(t)));
    }
    
    inline void updateTerm(const std::string& vocab_id,
                           const std::string& term_id,
                           const xmlNodePtr config_ptr)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::updateTerm,
                                               _1, boost::cref(term_id), config_ptr));
    }
    
    inline void removeTerm(const std::string& vocab_id,
                           const std::string& term_id)
    {
        updateVocabulary(vocab_id, boost::bind(&VocabularyConfig::removeTerm,
                                               _1, boost::cref(term_id)));
    }
    
    template <typename VocabularyUpdateFunction>
    inline boost::signals::connection registerForUpdates(VocabularyUpdateFunction f) const {
        boost::mutex::scoped_lock signal_lock(m_signal_mutex);
        return m_signal_vocabulary_updated.connect(f);
    }
    
    inline const std::string& getName(const std::string& vocab_id) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        VocabularyMap::const_iterator i = m_vocab_map.find(vocab_id);
        if (i == m_vocab_map.end())
            throw VocabularyNotFoundException(vocab_id);
        return i->second->getName();
    }

    inline const std::string& getComment(const std::string& vocab_id) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        VocabularyMap::const_iterator i = m_vocab_map.find(vocab_id);
        if (i == m_vocab_map.end())
            throw VocabularyNotFoundException(vocab_id);
        return i->second->getComment();
    }

    inline bool hasVocabulary(const std::string& vocab_id) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        return (m_vocab_map.find(vocab_id) != m_vocab_map.end());
    }
    
    inline bool hasTerm(const std::string& term_id) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        return (m_vocabulary.findTerm(term_id) != Vocabulary::UNDEFINED_TERM_REF);
    }
    
    inline VocabularyPtr getVocabulary(void) const {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        return VocabularyPtr(new Vocabulary(m_vocabulary));
    }

    inline std::string getVocabularyPath(void) const { return m_vocab_path; }

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

private:

    template <typename Function>
    inline void updateVocabulary(const std::string& vocab_id, Function f) {
        boost::mutex::scoped_lock manager_lock(m_mutex);
        VocabularyMap::iterator i = m_vocab_map.find(vocab_id);
        if (i == m_vocab_map.end())
            throw VocabularyNotFoundException(vocab_id);
        f(i->second);
        manager_lock.unlock();
        boost::mutex::scoped_lock signal_lock(m_signal_mutex);
        m_signal_vocabulary_updated();
    }
    
    
    typedef boost::shared_ptr<VocabularyConfig>     VocabularyConfigPtr;
    
    typedef PION_HASH_MAP<std::string, VocabularyConfigPtr, PION_HASH_STRING >  VocabularyMap;
    
    
    static const std::string            DEFAULT_CONFIG_FILE;
    
    static const std::string            DEFAULT_VOCABULARY_PATH;
    
    static const std::string            VOCABULARY_PATH_ELEMENT_NAME;

    static const std::string            VOCABULARY_CONFIG_ELEMENT_NAME;

    static const std::string            VOCABULARIES_PERMISSION_TYPE;

    std::string                         m_vocab_path;
    
    VocabularyMap                       m_vocab_map;
    
    Vocabulary                          m_vocabulary;

    mutable boost::signal0<void>        m_signal_vocabulary_updated;

    mutable boost::mutex                m_signal_mutex; 
    
    mutable boost::mutex                m_mutex;    
};


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

#endif

---