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 <boost/tuple/tuple.hpp>

#include "typename.hh"
  
namespace Typelib
{
    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:
        typedef std::map<Type const*, Type const*> RecursionStack;

        // 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;

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

        bool isSame(Type const& other) const;

        Type const& merge(Registry& registry) const;

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

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

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


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

    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 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_isSame(Type const& other, 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  {};
        class SymbolNotFound {};
        class ValueNotFound  {};
        
        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_isSame(Type const& other, 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);

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

    private:
        virtual bool do_isSame(Type const& other, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        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);
        Type const& getIndirection() const;
        virtual std::set<Type const*> dependsOn() const;

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

    protected:
        virtual bool do_isSame(Type const& other, RecursionStack& stack) const;

    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);

    private:
        virtual bool do_isSame(Type const& other, RecursionStack& stack) const;
        virtual Type* do_merge(Registry& registry, RecursionStack& stack) const;
        size_t m_dimension;
    };

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

    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 void insert(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;

        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* ptr) const = 0;

        virtual MarshalOps::const_iterator dump(
            void* container_ptr, size_t element_count,
            std::vector<uint8_t>& buffer,
            MarshalOps::const_iterator const begin, MarshalOps::const_iterator const end) const = 0;

        virtual boost::tuple<size_t, MarshalOps::const_iterator> load(
            void* container_ptr, size_t element_count,
            std::vector<uint8_t> const& buffer, size_t in_offset,
            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_isSame(Type const& other, 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