registry.hh

Go to the documentation of this file.

#ifndef TYPELIB_REGISTRY_H
#define TYPELIB_REGISTRY_H

#include "typemodel.hh"
#include <boost/shared_ptr.hpp>
#include <stdexcept>

namespace Typelib
{
    class RegistryIterator;
    
    class RegistryException : public std::runtime_error 
    { 
    public:
        RegistryException(std::string const& what) : std::runtime_error(what) {}
    };

    class Undefined : public RegistryException
    {
        std::string m_name;

    public:
        Undefined(const std::string& name)
            : RegistryException("undefined type '" + name + "'")
            , m_name(name) {}
        ~Undefined() throw() {}

        std::string getName() const { return m_name; }
    };

    class AlreadyDefined : public RegistryException
    {
        std::string m_name;

    public:
        AlreadyDefined(std::string const& name)
            : RegistryException("type " + name + " already defined in registry")
            , m_name(name) {}
        ~AlreadyDefined() throw() {}

        std::string getName() const { return m_name; }
    };

    class BadName : public RegistryException
    {
        const std::string m_name;

    public:
        BadName(const std::string& name)
            : RegistryException(name + " is not a valid type name")
            , m_name(name) {}
        ~BadName() throw() {}
    };

    class DefinitionMismatch : public RegistryException
    {
        const std::string m_name;

    public:
        DefinitionMismatch(const std::string& name)
            : RegistryException(name + " already defines a type in the registry, but with a different definition") {}
        ~DefinitionMismatch() throw() {}
    };


    class Registry
    {
        friend class RegistryIterator;
        
    private:
        struct RegistryType
        {
            Type*       type;
            bool        persistent;
            std::string source_id;
        };
        typedef std::map
            < const std::string
            , RegistryType
            , bool (*) (const std::string&, const std::string&)
            >     TypeMap;

        typedef std::map<const std::string, RegistryType>  NameMap;

        TypeMap                 m_global;
        NameMap                 m_current;
        std::string             m_namespace;

        static bool isPersistent(std::string const& name, Type const& type, std::string const& source_id);
        void add(std::string const& name, Type* new_type, bool persistent, std::string const& source_id);

        std::set<Type*> reverseDepends(Type const& type);

        void updateCurrentNameMap();

    public:
        typedef RegistryIterator Iterator;

        Registry();
        ~Registry();

        void importNamespace(const std::string& name, bool erase_existing = false);

        bool setDefaultNamespace(const std::string& name);
        std::string getDefaultNamespace() const;
       
        bool        has(const std::string& name, bool build = true) const;

        std::string source(Type const* type) const;

        Type const* build(const std::string& name, std::size_t size = 0);

        Type const* get(const std::string& name) const;  

        RegistryIterator find(std::string const& name) const;

        /* Internal version to get a non-const Type object
         *
         * You should not be using it. This is for internal Typelib use only */
        Type* get_(const std::string& name);

        std::set<Type const*> reverseDepends(Type const& type) const;

        std::set<Type *> remove(Type const& type);

        /* Internal version to get a non-const Type object
         *
         * You should not be using it. This is for internal Typelib use only */
        Type& get_(Type const& type);

        void        add(Type* type, std::string const& source_id = "");

        void        add(Type* type, bool persistent, std::string const& source_id);

        void        alias(std::string const& base, std::string const& alias, bool persistent, std::string const& source_id = "");

        void        alias(std::string const& base, std::string const& alias, std::string const& source_id = "");

        size_t      size() const;
        void        clear();

        std::string getFullName (const std::string& name) const;

        RegistryIterator begin() const;
        RegistryIterator end() const;
        RegistryIterator begin(std::string const& prefix) const;
        RegistryIterator end(std::string const& prefix) const;
        
        static Type const& null();

        void merge(Registry const& registry);

        void mergeMetaData(Registry const& registry);

        void resize(std::map<std::string, size_t> const& new_sizes);

        Registry* minimal(std::string const& name, bool with_aliases = true) const;

        Registry* minimal(Registry const& auto_types) const;

        bool isSame(Registry const& other) const;

        bool isIncluded(Type const& type) const;

        std::set<std::string> getAliasesOf(Type const& type) const;

        void setSourceID(Type const& type, std::string const& source_id);

        void copySourceIDs(Registry const& registry);

        void clearAliases();
        
    public:
        enum DumpMode
        {
            NameOnly = 0, 
            AllType  = 1, 
            WithSourceId = 2,
            RecursiveTypeDump = 4
        };
        void dump(std::ostream& stream, int dumpmode = AllType, const std::string& source_filter = "*") const;
    };
}

#endif