typemodel.hh

Go to the documentation of this file.

#ifndef __TYPELIB_TYPEMODEL_HH__
#define __TYPELIB_TYPEMODEL_HH__

#include <string>
#include <list>
#include <map>
#include <set>
#include <vector>
#include <stdint.h>
#include <stdexcept>

namespace Typelib
{
    struct OutputStream;
    struct InputStream;

    class Registry;

    class Type 
    {
    public:

        enum Category
        { 
            NullType = 0,
            Array  , 
            Pointer, 
            Numeric, 
            Enum   ,
            Compound,
            Opaque,
            Container
        };
        static const int ValidCategories = Compound + 1;
        
    private:
        std::string m_name;

        size_t      m_size;
        Category    m_category;

        static bool isValidIdentifier(const std::string& identifier);

    protected:

        // Creates a basic type from \c name, \c size and \c category
        Type(const std::string& name, size_t size, Category category);

    public:
        virtual ~Type();

        void setName    (const std::string& name);
        void setSize    (size_t size);
        std::string   getName() const;
        std::string   getBasename() const;
        std::string   getNamespace() const;
        size_t        getSize() const;
        Category      getCategory() const;
        bool          isNull() const;

        virtual std::set<Type const*> dependsOn() const = 0;

        virtual void modifiedDependencyAliases(Registry& registry) const;

        bool operator == (Type const& with) const;
        bool operator != (Type const& with) const;

        bool isSame(Type const& other) const;

        bool canCastTo(Type const& to) const;

        Type const& merge(Registry& registry) const;

        typedef std::map<Type const*, Type const*> RecursionStack;

        virtual Type const& merge(Registry& registry, RecursionStack& stack) const;

        virtual bool resize(Registry& registry, std::map<std::string, std::pair<size_t, size_t> >& new_sizes);

        virtual unsigned int getTrailingPadding() const;

    protected:
        virtual bool do_compare(Type const& other, bool equality, std::map<Type const*, Type const*>& stack) const;

        bool rec_compare(Type const& left, Type const& right, bool equality, RecursionStack& stack) const;

        Type const* try_merge(Registry& registry, RecursionStack& stack) const;

        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const = 0;

        virtual bool do_resize(Registry& into, std::map<std::string, std::pair<size_t, size_t> >& new_sizes);
    };

    class NullType : public Type
    {
    public:
        NullType(std::string const& name) : Type(name, 0, Type::NullType ) {}
        virtual std::set<Type const*> dependsOn() const { return std::set<Type const*>(); }

    private:
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const { return new NullType(*this); }
    };

    class OpaqueType : public Type
    {
    public:
        OpaqueType(std::string const& name, size_t size) : Type(name, size, Type::Opaque) {}
        virtual std::set<Type const*> dependsOn() const { return std::set<Type const*>(); }
        virtual bool do_compare(Type const& other, bool equality, std::map<Type const*, Type const*>& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const { return new OpaqueType(*this); }
    };

    class Numeric : public Type
    {
    public:
        enum NumericCategory
        { 
            SInt = Type::ValidCategories, 
            UInt,                         
            Float                         
        };
        static const int ValidCategories = Float + 1;

        NumericCategory getNumericCategory() const;

    public:
        Numeric(const std::string& name, size_t size, NumericCategory category);

        virtual std::set<Type const*> dependsOn() const { return std::set<Type const*>(); }

    private:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        NumericCategory m_category;
    };

    class Enum : public Type
    {
    public:
        typedef int integral_type;
        typedef std::map<std::string, int> ValueMap;

        class AlreadyExists : public std::runtime_error
        {
        public:
            AlreadyExists(Type const& type, std::string const& name);
        };
        class SymbolNotFound : public std::runtime_error
        {
        public:
            SymbolNotFound(Type const& type, std::string const& name);
        };
        class ValueNotFound : public std::runtime_error
        {
        public:
            ValueNotFound(Type const& type, int value);
        };
        
        Enum(const std::string& name, Enum::integral_type initial_value = 0);
        void            add(std::string const& name, int value);
        integral_type   get(std::string const& name) const;
        std::string     get(integral_type value) const;
        
        std::list<std::string> names() const;
        ValueMap const& values() const;

        virtual std::set<Type const*> dependsOn() const { return std::set<Type const*>(); }

        Enum::integral_type getNextValue() const;

    private:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        integral_type m_last_value;
        ValueMap m_values;
    };

    class Field
    {
        friend class Compound;

        std::string m_name;
        const Type& m_type;
        size_t m_offset;

    protected:
        void setOffset(size_t offset);

    public:
        Field(const std::string& name, Type const& base_type);

        std::string getName() const;
        const Type& getType() const;
        size_t getOffset() const;

        bool operator == (Field const& field) const;
    };

    class Compound : public Type
    {
    public:
        typedef std::list<Field> FieldList;

    public:
        Compound(std::string const& name);

        FieldList const&  getFields() const;
        Field const*      getField(const std::string& name) const;
        void              addField(const Field& field, size_t offset);
        void              addField(const std::string& name, const Type& type, size_t offset);

        unsigned int getTrailingPadding() const;

        virtual std::set<Type const*> dependsOn() const;

    private:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        bool do_resize(Registry& registry, std::map<std::string, std::pair<size_t, size_t> >& new_sizes);
        FieldList m_fields;
    };

    class Indirect : public Type
    {
    public:
        static const int ValidIDs = Type::Pointer | Type::Array;

    public:

        Indirect(std::string const& name, size_t size, Category category, Type const& on);

        void modifiedDependencyAliases(Registry& registry) const;

        Type const& getIndirection() const;
        virtual std::set<Type const*> dependsOn() const;

        virtual Type const& merge(Registry& registry, RecursionStack& stack) const;

    protected:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual bool do_resize(Registry& registry, std::map<std::string, std::pair<size_t, size_t> >& new_sizes);

        virtual std::string getIndirectTypeName(std::string const& inside_name) const = 0;

    private:
        Type const& m_indirection;
    };

    class Array : public Indirect
    {
    public:

        Array(Type const& of, size_t dimension);
        size_t getDimension() const;
        static std::string getArrayName(std::string const& base, size_t new_dim);

    protected:
        virtual std::string getIndirectTypeName(std::string const& inside_name) const;

    private:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        virtual bool do_resize(Registry& into, std::map<std::string, std::pair<size_t, size_t> >& new_sizes);
        size_t m_dimension;
    };

    class Pointer : public Indirect
    {
    public:
        Pointer(Type const& on);
        static std::string getPointerName(std::string const& base);

    protected:
        virtual std::string getIndirectTypeName(std::string const& inside_name) const;

    private:
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
    };

    struct UnknownContainer : public std::runtime_error
    {
        UnknownContainer(std::string const& name)
            : std::runtime_error("unknown container " + name) {}
    };

    class ValueVisitor;
    class Value;

    class Container : public Indirect
    {
        std::string m_kind;


    protected:
        struct DeleteIfPredicate
        {
            virtual bool should_delete(Value const& v) = 0;
        };

        virtual void delete_if_impl(void* ptr, DeleteIfPredicate& pred) const = 0;

    private:
        template<typename Pred>
        struct PredicateWrapper : public DeleteIfPredicate
        {
            Pred pred;

            PredicateWrapper(Pred pred)
                : pred(pred) {}

            virtual bool should_delete(Value const& v)
            {
                return pred(v);
            };
        };


    public:
        typedef std::vector<size_t> MarshalOps;

        Container(std::string const& kind, std::string const& name, size_t size, Type const& of);

        std::string kind() const;
        virtual void init(void* ptr) const = 0;
        virtual void destroy(void* ptr) const = 0;
        virtual bool visit(void* ptr, ValueVisitor& visitor) const = 0;

        virtual bool isRandomAccess() const;

        virtual Typelib::Value getElement(void* ptr, int idx) const;

        virtual void setElement(void* ptr, int idx, Typelib::Value value) const;

        virtual void clear(void* ptr) const = 0;

        virtual void push(void* ptr, Value v) const = 0;

        virtual bool erase(void* ptr, Value v) const = 0;

        virtual bool compare(void* ptr, void* other) const = 0;

        virtual void copy(void* dst, void* src) const = 0;

        virtual long getNaturalSize() const = 0;

        template<typename Pred>
        void delete_if(void* ptr, Pred pred) const
        {
            PredicateWrapper<Pred> predicate(pred);
            delete_if_impl(ptr, predicate);
        }

        virtual size_t getElementCount(void const* ptr) const = 0;

        virtual MarshalOps::const_iterator dump(
            void const* container_ptr, size_t element_count,
            OutputStream& stream,
            MarshalOps::const_iterator const begin, MarshalOps::const_iterator const end) const = 0;

        virtual MarshalOps::const_iterator load(
            void* container_ptr, size_t element_count,
            InputStream& stream,
            MarshalOps::const_iterator const begin, MarshalOps::const_iterator const end) const = 0;

        typedef Container const& (*ContainerFactory)(Registry& r, std::list<Type const*> const& base_type);
        typedef std::map<std::string, ContainerFactory> AvailableContainers;

        static AvailableContainers availableContainers();
        static void registerContainer(std::string const& name, ContainerFactory factory);
        static Container const& createContainer(Registry& r, std::string const& name, Type const& on);
        static Container const& createContainer(Registry& r, std::string const& name, std::list<Type const*> const& on);

    protected:
        virtual bool do_compare(Type const& other, bool equality, RecursionStack& stack) const;
        virtual ContainerFactory getFactory() const = 0;
        Type* do_merge(Registry& registry, RecursionStack& stack) const;

    private:
        static AvailableContainers* s_available_containers;
    };

    struct TypeException : public std::runtime_error
    {
        TypeException(std::string const& msg) : std::runtime_error(msg) { }
    };

    struct BadCategory : public TypeException
    {
        Type::Category const found;
        int            const expected;

        BadCategory(Type::Category found, int expected);
    };

    struct NullTypeFound : public TypeException
    {
        NullTypeFound();
    };
};

#endif