platform/include/pion/platform/Vocabulary.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_VOCABULARY_HEADER__
#define __PION_VOCABULARY_HEADER__

#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PionHashMap.hpp>


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


class PION_PLATFORM_API Vocabulary
{
public:

    typedef unsigned long       TermRef;
    
    static const TermRef        UNDEFINED_TERM_REF;
    
    enum DataType {
        TYPE_NULL = 0,          
        TYPE_INT8,              
        TYPE_UINT8,             
        TYPE_INT16,             
        TYPE_UINT16,            
        TYPE_INT32,             
        TYPE_UINT32,            
        TYPE_INT64,             
        TYPE_UINT64,            
        TYPE_FLOAT,             
        TYPE_DOUBLE,            
        TYPE_LONG_DOUBLE,       
        TYPE_SHORT_STRING,      
        TYPE_STRING,            
        TYPE_LONG_STRING,       
        TYPE_DATE_TIME,         
        TYPE_DATE,              
        TYPE_TIME,              
        TYPE_CHAR,              
        TYPE_BLOB,              
        TYPE_ZBLOB,             
        TYPE_OBJECT             
    };
    
    struct Term {
        Term(void)
            : term_ref(UNDEFINED_TERM_REF),
            term_type(TYPE_NULL), term_size(0)
            {}
        Term(const std::string& id)
            : term_id(id), term_ref(UNDEFINED_TERM_REF),
            term_type(TYPE_NULL), term_size(0)
            {}
        Term(const Term& t)
            : term_id(t.term_id), term_ref(t.term_ref),
            term_comment(t.term_comment), term_type(t.term_type),
            term_size(t.term_size), term_format(t.term_format)
            {}
        inline Term& operator=(const Term& t) {
            term_id = t.term_id;
            term_ref = t.term_ref;
            term_comment = t.term_comment;
            term_type = t.term_type;
            term_size = t.term_size;
            term_format = t.term_format;
            return *this;
        }
        std::string             term_id;
        TermRef                 term_ref;
        std::string             term_comment;
        DataType                term_type;
        size_t                  term_size;
        std::string             term_format;
    };
    
    typedef boost::shared_ptr<Term>     TermPtr;
    
    class EmptyTermIdException : public std::exception {
    public:
        virtual const char* what() const throw() {
            return "Tried adding a vocabulary term with an empty identifier";
        }
    };
    
    class UnknownDataTypeException : public PionException {
    public:
        UnknownDataTypeException(const std::string& data_type)
            : PionException("Could not parse unknown data type: ", data_type) {}
    };

    class DuplicateTermException : public PionException {
    public:
        DuplicateTermException(const std::string& term_id)
            : PionException("Tried adding a duplicate term to the Vocabulary: ", term_id) {}
    };
    
    class TermNotFoundException : public PionException {
    public:
        TermNotFoundException(const std::string& term_id)
            : PionException("Unable to find Term identifier: ", term_id) {}
    };

    class TermNoLongerDefinedException : public PionException {
    public:
        TermNoLongerDefinedException(const std::string& term_id)
            : PionException("Term was removed from Vocabulary while still in-use: ", term_id) {}
    };

    
    ~Vocabulary() {}
        
    Vocabulary(void);
    
    Vocabulary(const Vocabulary& v);
    
    inline size_t size(void) const { return m_num_terms; }  
    
    inline const Term& operator[](const TermRef& term_ref) const {
        PION_ASSERT(term_ref <= m_num_terms);
        return *(m_ref_map[term_ref]);
    }
    
    inline TermRef findTerm(const std::string& term_id) const {
        TermRef term_ref = UNDEFINED_TERM_REF;
        TermStringMap::const_iterator i = m_uri_map.find(term_id);
        if (i != m_uri_map.end())
            term_ref = i->second->term_ref;
        return term_ref;
    }

    inline const Term& findTerm(const TermRef& term_ref) const {
        return *m_ref_map[(term_ref > m_num_terms ? UNDEFINED_TERM_REF : term_ref)];
    }

    TermRef addTerm(const Term& t);
    
    void removeTerm(const std::string& term_id);
    
    void updateTerm(const Term& t);

    void refreshTerm(Term& t) const;
    
    const Vocabulary& operator+=(const Vocabulary& v);
    
    static DataType parseDataType(std::string str);
    
    static std::string getDataTypeAsString(const DataType type);
    
    
private:

    Vocabulary& operator=(const Vocabulary& v);


    typedef PION_HASH_MAP<std::string, TermPtr, PION_HASH_STRING >  TermStringMap;
    
    typedef std::vector<TermPtr>                    TermRefMap;
    
    
    TermRefMap                      m_ref_map;

    TermStringMap                   m_uri_map;
    
    TermRef                         m_num_terms;
};


typedef boost::shared_ptr<Vocabulary>   VocabularyPtr;


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

#endif

---