Reflection.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <string>
#include <map>
#include <assert.h>
#include <functional>
 
#include "../Types.h"
#include "../Containers/Collection.h"
#include "../Containers/Hashmap.h"
#include "../Enum.h"
#include "../Any.h"
#include "../Utils/Assert.h"
 
#include "Data.h"
#include "Exceptions.h"
 
namespace Gorgon {
    
    namespace Scripting {
        
        class Type;
        class Data;
        class VirtualMachine;
        
        Type *TypeType();
 
        namespace Types {
            const Scripting::Type &Type();
            const Scripting::Type &Namespace();
            const Scripting::Type &Constant();
            const Scripting::Type &Function();
            const Scripting::Type &StaticDataMember();
            const Scripting::Type &Library();
            const Scripting::Type &EnumType();
            const Scripting::Type &EventType();
            const Scripting::Type &InstanceMember();
        }
        
        
        
        template<class T_>
        std::string GetNameOf(const T_ &val) {
            return val.GetName();
        }
        
        template<class T_>
        std::string GetHelpOf(const T_ &val) {
            return val.GetHelp();
        }
        
        enum Tag {
            OptionalTag,
            
            ReferenceTag,
            
            InputTag,
            
            //OutputTag,
            
            MethodTag,
            
            RepeatTag,
            
            StretchTag,
            
            KeywordTag,
            
            PrivateTag,
            
            PublicTag,
            
            StaticTag,
            
            OperatorTag,
            
            ConstTag,
            
            ReturnsConstTag,
            
            VariableTag,
            
            ImplicitTag,
            
            AllowNullTag,
            
            ReadonlyTag,
        };
        
        typedef std::vector<Any> OptionList;
        
        class Parameter {
        public:
            
            template <class ...Params_>
            Parameter(const std::string &name, const std::string &help, const Type *type, 
                     Data defaultvalue, OptionList options, Params_ ...tags) : 
            name(name), type(type), help(help), defaultvalue(defaultvalue) {
                ASSERT((type!=nullptr), "Parameter type cannot be nullptr", 1, 2);
                using std::swap;
 
                swap(options, this->Options);
 
                UnpackTags(tags...);
            }
            
            Parameter(const std::string &name, const std::string &help, const Type *type, Data defaultvalue=Data::Invalid()) : 
            Parameter(name, help, type, defaultvalue, OptionList()) { }
            
            template <class ...Params_>
            Parameter(const std::string &name, const std::string &help, const Type *type, Tag firsttag,
                      Params_ ...tags) : 
            Parameter(name, help, type, Data::Invalid(), OptionList(), firsttag, std::forward<Params_>(tags)...) {
            }
            
            template <class ...Params_>
            Parameter(const std::string &name, const std::string &help, const Type *type, Data defaultvalue,
                      Tag firsttag, Params_ ...tags) : 
            Parameter(name, help, type, defaultvalue, OptionList(), firsttag, std::forward<Params_>(tags)...) {
            }
             
            Parameter(const std::string &name, const std::string &help, const Type *type, 
                      Data defaultvalue, OptionList options, bool reference, bool constant, bool variable, bool allownull) :
            Parameter(name, help, type, defaultvalue, options)
            {
                this->reference = reference;
                this->constant  = constant;
                this->variable  = variable;
                this->optional  = defaultvalue.IsValid();
                this->allownull = allownull;
            }
            
            Parameter &operator =(const Parameter &p) {
                name        = p.name        ;
                help        = p.help        ;
                type        = p.type        ;
                defaultvalue= p.defaultvalue;
                Options     = p.Options     ;
                optional    = p.optional    ;
                reference   = p.reference   ;
                constant    = p.constant    ;
                variable    = p.variable    ;
                allownull   = p.allownull   ;
                
                return *this;
            }
            
            bool operator ==(const Parameter &p) const {
                return 
                    name        == p.name       &&
                    help        == p.help       &&
                    type        == p.type       &&
                    optional    == p.optional   &&
                    reference   == p.reference  &&
                    constant    == p.constant   &&
                    variable    == p.variable   &&
                    allownull   == p.allownull  ;
            }
            
            std::string GetName() const {
                return name;
            }
            
            std::string GetHelp() const {
                return help;
            }
            
            const Type &GetType() const {
                return *type;
            }
            
            bool IsOptional() const {
                return optional;
            }
            
            bool IsReference() const;
            
            bool IsConstant() const {
                return constant;
            }
            
            bool IsVariable() const {
                return variable;
            }
            
            bool AllowsNull() const {
                return allownull;
            }
            
            Data GetDefaultValue() const {
                ASSERT(optional, name+" parameter does not have default value");
                
                return defaultvalue;
            }
            
            OptionList Options;
            
        private:
            void UnpackTags() {}
            
            template<class ...Params_>
            void UnpackTags(Tag tag, Params_ ...tags) {
                switch(tag) {
                    case OptionalTag:
                        optional=true;
                        break;
                        
                    case ReferenceTag:
                        reference=true;
                        break;
                        
                    case ConstTag:
                        constant=true;
                        break;
                        
                    case VariableTag:
                        variable=true;
                        break;
                        
                    case AllowNullTag:
                        allownull=true;
                        break;
                        
                    default:
                        Utils::ASSERT_FALSE("Unknown tag");
                }
                UnpackTags(tags...);
            }
            
            
            std::string name;
            std::string help;
            const Type *type;
            Data defaultvalue=Data::Invalid();
            
            bool optional  = false;
            bool reference = false;
            bool constant  = false;
            bool variable  = false;
            bool allownull = false;
        };
        
        using ParameterList = std::vector<Parameter>;
        
        class Member {
            friend class Namespace;
            friend class Type;
        public:
            
            Member(const std::string &name, const std::string &help) : 
            name(name), help(help) { }
            
            virtual ~Member() { }
            
            std::string GetName() const {
                return name;
            }
            
            std::string GetHelp() const {
                return help;
            }
            
            virtual bool IsInstanceMember() const = 0;
            
            std::string GetQualifiedName() const {
                if(!parent)
                    return name;
                
                return parent->GetQualifiedName()+":"+name;
            }
            
            const Member *GetOwner() const { return parent; }
            
        protected:
            virtual void SetParent(const Member &parent) { this->parent=&parent; }
            
            std::string name;
            
            std::string help;
            
            const Member *parent = nullptr;
        };
        
        class StaticMember : public Member {
        public:
            enum MemberType {
                RegularType = 1,
                
                EventType = 3,
                
                EnumType = 5,
                
                Namespace = 8,
                
                DataMember = 10,
                
                Function = 12,
                
                Constant = 14,
            };
 
            StaticMember(const std::string& name, const std::string& help) : Member(name, help) {
            }
 
            virtual bool IsInstanceMember() const override final { return false; }
            
            bool IsInstanceable() const {
                return (GetMemberType()&1) != 0;
            }
            
            virtual MemberType GetMemberType() const = 0;
            
            virtual Data Get() const = 0;
            
        };
        
        DefineEnumStringsCM(StaticMember, MemberType,
            {StaticMember::RegularType, "RegularType"},
            {StaticMember::EventType, "EventType"},
            {StaticMember::EnumType, "EnumType"},
            {StaticMember::Namespace, "Namespace"},
            {StaticMember::DataMember, "DataMember"},
            {StaticMember::Function, "Function"},
            {StaticMember::Constant, "Constant"},
        );
        
        class StaticDataMember : public StaticMember {
        public:
            StaticDataMember(const std::string &name, const std::string &help, const Type *type, 
                             bool constant, bool ref, bool readonly) :
            StaticMember(name, help), type(type), constant(constant), reference(ref), readonly(readonly)
            {
            }
            
            StaticDataMember(const std::string& name, const std::string& help, const Type *type) : 
            StaticDataMember(name, help, type, false, false, false) { }
            
            template <class ...P_>
            StaticDataMember(const std::string& name, const std::string& help, const Type *type, Tag first, P_ ...rest) : 
            StaticDataMember(name, help, type, false, false, false) { 
                UnpackTags(first);
                UnpackTags(rest...);
            }
            
            
            virtual MemberType GetMemberType() const override {
                return StaticMember::DataMember;
            }
            
            void Set(Data &newval) {
                if(readonly) {
                    throw ReadOnlyException(name);
                }
                
                set(newval);
            }
            
            virtual Data Get() const override {
                Data d=get();
                ASSERT(!reference  || d.IsReference(), "The value returned from "+name+" should be a reference");
                if(constant)
                    d.MakeConstant();
                
                return d;
            }
            
            const Type &GetType() const {
                return *type;
            }           
 
            bool IsConstant() const {
                return constant;
            }
            
            bool IsReference() const {
                return reference;
            }
            
            bool IsReadonly() const {
                return readonly;
            }
            
            
        protected:
            
            virtual void set(Data &newval) = 0;
            
            virtual Data get() const = 0;
            
            const Type *type;
            
            bool constant;
            
            bool reference;
            
            bool readonly;
            
        private:
            void UnpackTags() {}
            
            template<class ...Params_>
            void UnpackTags(Tag tag, Params_ ...tags) {
                switch(tag) {
                    case ConstTag:
                        constant=true;
                        break;
                        
                    case ReferenceTag:
                        reference=true;
                        break;
                        
                    case ReadonlyTag:
                        readonly=true;
                        break;
                        
                    default:
                        Utils::ASSERT_FALSE("Unknown tag");
                }
                UnpackTags(tags...);
            }
        };
        
        
        using StaticMemberList = Containers::Hashmap<std::string, const StaticMember, GetNameOf<StaticMember>, std::map, String::CaseInsensitiveLess>;
        
        class Function : public StaticMember {
            friend class Type;
        public:
            
            class Overload {
                friend class Function;
            public:
                template<class ...P_>
                Overload(const Type *returntype, ParameterList parameters, P_ ...tags) :
                returntype(returntype), Parameters(this->parameters)
                {
                    using std::swap;
                    swap(parameters, this->parameters);
                    
                    unpacktags(tags...);
                }
                
                Overload(const Type *returntype, ParameterList parameters, bool stretchlast, bool repeatlast, 
                        bool accessible, bool constant, bool returnsref, bool returnsconst, bool implicit) :
                returntype(returntype), stretchlast(stretchlast), repeatlast(repeatlast), 
                accessible(accessible), constant(constant), returnsref(returnsref), returnsconst(returnsconst),
                implicit(implicit), Parameters(this->parameters)
                {
                    using std::swap;
                    swap(parameters, this->parameters);
                }
                
                virtual ~Overload() { }
                
                bool IsSame(const Overload &var) const;
                
                bool StretchLast() const {
                    return stretchlast;
                }
                
                bool RepeatLast() const {
                    return repeatlast;
                }
                
                bool IsConstant() const {
                    return constant;
                }
                
                bool ReturnsRef() const {
                    return returnsref;
                }
                
                bool ReturnsConst() const {
                    return returnsconst;
                }
                
                const Function &GetParent() const {
                    ASSERT(parent, "Parent is not set");
                    
                    return *parent;
                }
                
                bool HasReturnType() const {
                    return returntype!=nullptr;
                }
                
                const Type &GetReturnType() const {
                    ASSERT(returntype, "This function does not return a value");
                    
                    return *returntype;
                }
                
                bool IsImplicit() const {
                    return implicit;
                }
        
                virtual Data Call(bool ismethod, const std::vector<Data> &parameters) const = 0;
                
                const ParameterList &Parameters;
                
            protected:
            
                void unpacktags() {}
                
                template<class ...P_>
                void unpacktags(Tag tag, P_ ...rest) {
                    switch(tag) {
                        case ConstTag:
                            constant=true;
                            break;
                            
                        case StretchTag:
                            stretchlast=true;
                            break;
                            
                        case RepeatTag:
                            repeatlast=true;
                            break;
                            
                        case PublicTag:
                            accessible=true;
                            break;
                            
                        case PrivateTag:
                            accessible=false;
                            break;
                            
                        case ReferenceTag:
                            returnsref=true;
                            break;
                            
                        case ReturnsConstTag:
                            returnsconst=true;
                            break;
                            
                        case ImplicitTag:
                            implicit=true;
                            break;
                            
                        default:
                            ASSERT(false, "Unknown tag", 2, 16);
                    }
                    
                    unpacktags(rest...);
                }
                
                virtual void dochecks(bool ismethod);
                
                ParameterList parameters;
                
                const Type *returntype = nullptr;
            
                bool stretchlast = false;
                
                bool repeatlast = false;
                
                bool accessible = true;
                
                bool constant = false;
                
                bool returnsref = false;
                
                bool returnsconst = false;
                
                Function *parent;
                
                bool implicit = false;
            };
            
            template<class ...P_>
            Function(const std::string &name, const std::string &help, const Type *parent, 
                     const Containers::Collection<Overload> &overloads, const Containers::Collection<Overload> &methods, 
                     Tag tag, P_ ...tags) : 
            StaticMember(name, help), parent(parent), Overloads(this->overloads), Methods(this->methods)
            {
                
                unpacktags(tag);
                unpacktags(tags...);
                
                for(auto &variant : overloads) {
                    AddOverload(variant);
                }
                
                for(auto &variant : methods) {
                    AddMethod(variant);
                }
                
                init();
            }
            
            template<class ...P_>
            Function(const std::string &name, const std::string &help, const Type *parent, 
                     const Containers::Collection<Overload> &overloads, Tag tag, P_ ...tags) :
            StaticMember(name, help), parent(parent), Overloads(this->overloads), Methods(this->methods)
            {
                unpacktags(tag);
                unpacktags(tags...);
                
                for(auto &overload : overloads) {
                    AddOverload(overload);
                }               
 
                init();
            }
            
            template<class ...P_>
            Function(const std::string &name, const std::string &help, const Type *parent,
                     const Containers::Collection<Overload> &overloads, const Containers::Collection<Overload> &methods=Containers::Collection<Overload>()
            ) : 
            StaticMember(name, help), parent(parent), Overloads(this->overloads), Methods(this->methods)
            { 
                for(auto &overload : overloads) {
                    AddOverload(overload);
                }
                
                for(auto &overload : methods) {
                    AddMethod(overload);
                }
 
                init();
            }
 
            template<class ...P_>
            Function(const std::string &name, const std::string &help, const Type *parent, 
                     bool keyword, bool isoperator, bool staticmember) : 
            Function(name, help, parent, Containers::Collection<Overload>()) {
                this->keyword=keyword;
                this->isoperator=isoperator;
                this->staticmember=staticmember;
 
                init();
            }
            
            Function(const Function &) = delete;
 
            virtual ~Function() { 
                overloads.Destroy();
                methods.Destroy();
            } 
 
            virtual MemberType GetMemberType() const override {
                return StaticMember::Function;
            }
            
            virtual Data Get() const override final;
            
            virtual void SetParent(const Member &parent) override final;
            
            bool IsKeyword() const {
                return keyword;
            }
            
            bool IsStatic() const {
                return staticmember;
            }
 
            bool IsMember() const {
                return parent!=nullptr;
            }
                
            bool IsOperator() const {
                return isoperator;
            }
            
            const Type &GetOwner() const {
                ASSERT(parent, "This function does not have an owner.", 1, 5);
                
                return *parent;
            }
            
            virtual void AddOverload(Overload &overload) {
                ASSERT(
                    !isoperator || overload.parameters.size()==1,
                    "Operators should have only a single parameter\n"                   
                    "in function "+name, 1, 3
                );
 
                overload.parent=this;
                for(const auto &v : overloads) {
                    if(overload.IsSame(v)) {
                        throw AmbiguousSymbolException(name, SymbolType::Function, "Ambiguous function variant");
                    }
                }
                
#ifndef NDEBUG
                overload.dochecks(false);
#endif
                overloads.Push(overload);
            }
            
            virtual void AddMethod(Overload &overload) {
                ASSERT(!isoperator, "Operators cannot be methods\n in function "+name, 1, 3);
                
                overload.parent=this;
                for(const auto &v : methods) {
                    if(overload.IsSame(v)) {
                        throw AmbiguousSymbolException(name, SymbolType::Function, "Ambiguous function variant");
                    }
                }
                
#ifndef NDEBUG
                overload.dochecks(true);
#endif
                methods.Push(overload);
            }
            
            virtual void AddOverload(Overload *overload) {
                ASSERT(overload, "Empty variant\n in function "+name);
 
                AddOverload(*overload);
            }
            
            virtual void AddMethod(Overload *overload) {
                ASSERT(overload, "Empty variant\n in function "+name);
 
                AddMethod(*overload);
            }
            
            const Containers::Collection<Overload> &Overloads;
            
            const Containers::Collection<Overload> &Methods;
            
        private:
            
            void unpacktags() {}
            
            template<class ...P_>
            void unpacktags(Tag tag, P_ ...rest) {
                switch(tag) {
                    case KeywordTag:
                        keyword=true;
                        break;
                        
                    case StaticTag:
                        staticmember=true;
                        ASSERT(!isoperator, "A function cannot be a static operator");
                        break;
                        
                    case OperatorTag:
                        isoperator=true;
                        ASSERT(!staticmember, "A function cannot be a static operator");
                        ASSERT(parent, "Operators should be member functions");
 
                        break;
                        
                    default:
                        ASSERT(false, "Unknown tag", 2, 16);
                }
                
                unpacktags(rest...);
            }
 
            void init();
 
            
            const Type *parent = nullptr;
            
            bool keyword = false;
            
            bool isoperator = false;
            
            bool staticmember = false;
            
            Containers::Collection<Overload> overloads;
            
            Containers::Collection<Overload> methods;
        };
 
        class InstanceMember : public Member {
            friend class Type;
        public:
            
            InstanceMember(const std::string &name, const std::string &help, 
                       const Type &type, bool constant=false, bool ref=false, bool readonly=false) :
            Member(name, help), type(&type), constant(constant), reference(ref), readonly(readonly) 
            {
            }
            
            virtual bool IsInstanceMember() const override final { return true; }
            
            const Type &GetType() const {
                return *type;
            }
 
            Data Get(      Data &source) const {
                Data d=get(source);
                ASSERT(!reference  || d.IsReference(), "The value returned from "+name+" should be a reference");
                if(constant)
                    d.MakeConstant();
                
                return d;
            }
            
            void Set(Data &source, Data &value) const {
                if(readonly) {
                    throw ReadOnlyException(name);
                }
                
                set(source, value);
            }
            bool IsConstant() const {
                return constant;
            }
            
            bool IsReference() const {
                return reference;
            }
            
            bool IsReadonly() const {
                return readonly;
            }
            
            virtual ~InstanceMember() { }
            
        protected:
            virtual void set(Data &source, Data &value) const = 0;
            
            virtual Data get(      Data &source) const = 0;
            
            virtual void typecheck(const Type *type) const = 0;
            
            const Type *type;
            
            bool constant;
            
            bool reference;
            
            bool readonly;
        };
        
        using InstanceMemberList = Containers::Hashmap<std::string, const InstanceMember, GetNameOf<InstanceMember>, std::map, String::CaseInsensitiveLess>;
        
        class Namespace : public StaticMember {
        public:
            Namespace(const std::string &name, const std::string &help) : StaticMember(name, help), 
            Members(members) {
            }
            
            virtual MemberType GetMemberType() const override {
                return StaticMember::DataMember;
            }
            
            virtual Data Get() const override {
                return {Types::Namespace(), dynamic_cast<const Namespace*>(this), true, true};
            }
            
            virtual void AddMember(StaticMember &member) {
                ASSERT(!members.Find(member.GetName()).IsValid(), "Symbol "+member.GetName()+" is already added.");
 
                members.Add(member);
                member.SetParent(*this);
            }
            virtual void AddMember(StaticMember *member) {
                ASSERT(member!=nullptr, "Member is null");
                ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
 
                members.Add(member);
                member->SetParent(*this);
            }
            
            virtual void AddMembers(std::initializer_list<StaticMember*> newmembers) {
                for(auto member : newmembers) {
                    ASSERT(member!=nullptr, "Member is null");
                    ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    members.Add(member);
                    member->SetParent(*this);
                }
            }
            
            virtual void AddMembers(std::vector<StaticMember*> newmembers) {
                for(auto member : newmembers) {
                    ASSERT(member!=nullptr, "Member is null");
                    ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    members.Add(member);
                    member->SetParent(*this);
                }
            }
            
            const Namespace &GetNamespace(const std::string &name) const;
            
            const Type &GetType(const std::string &name) const;
            
            const Scripting::Function &GetFunction(const std::string &name) const;
            
            Data ValueOf(const std::string &name) const {
                auto elm=members.Find(name);
                if(!elm.IsValid())
                    throw SymbolNotFoundException(name, SymbolType::Identifier,"Symbol "+name+" cannot be found.");
                
                return elm.Current().second.Get();
            }
            
            const StaticMemberList &Members;
            
        protected:
            
            StaticMemberList members; 
        };
        
        class Type : public Namespace {
        public:
            
            enum MorphType {
                NotPossible,
 
                AlreadMatching,
                
                UpCasting,
                
                DownCasting,
                
                TypeCasting,
                
            };
            
            class Inheritance {
                friend class Type;
                
            public:
                using ConversionFunction = std::function<Data(Data)>;
                
                Inheritance(const Type &target, ConversionFunction from, ConversionFunction to) : 
                target(target), from(from), to(to) { }
                
                const Type &target;
                
            private:
                ConversionFunction from, to;
            };
            
            Type(const std::string &name, const std::string &help, const Any &defaultvalue, 
                 TMP::RTTH *typeinterface, bool isref);
            
            virtual MemberType GetMemberType() const override { return StaticMember::RegularType; }
            
            virtual Data Get() const override {
                Type *TypeType( );
                
                return {TypeType(), dynamic_cast<const Type*>(this), true, true};
            }
            
            virtual void AddMember(StaticMember &member) override {
                ASSERT(!instancemembers.Find(member.GetName()).IsValid(), "Symbol "+member.GetName()+" is already added.");
                
                Namespace::AddMember(member);
            }
            
            virtual void AddMember(StaticMember *member) override {
                ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                
                Namespace::AddMember(member);
            }
            
            virtual void AddMembers(std::initializer_list<StaticMember*> newmembers) override {
                for(auto member : newmembers) {
                    ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    Namespace::AddMember(*member);
                }
            }
            
            virtual void AddMembers(std::vector<StaticMember*> newmembers) override {
                for(auto member : newmembers) {
                    ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    Namespace::AddMember(*member);
                }
            }
            
            virtual void AddMember(InstanceMember &member) {
                member.typecheck(this);
                
                ASSERT(!members.Find(member.GetName()).IsValid(), "Symbol "+member.GetName()+" is already added.");
                ASSERT(!instancemembers.Find(member.GetName()).IsValid(), "Symbol "+member.GetName()+" is already added.");
                
                instancemembers.Add(member);
                member.SetParent(*this);
            }
            
            virtual void AddMember(InstanceMember *member) {
                member->typecheck(this);
                
                ASSERT(member!=nullptr, "Member is null");
                
                ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                
                instancemembers.Add(member);
                member->SetParent(*this);
            }
            
            virtual void AddMembers(std::initializer_list<InstanceMember*> newmembers) {
                for(auto member : newmembers) {
                    member->typecheck(this);
                    
                    ASSERT(member!=nullptr, "Member is null");
                    ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    instancemembers.Add(member);
                    member->SetParent(*this);
                }
            }
            
            virtual void AddMembers(std::vector<InstanceMember*> newmembers) {
                for(auto member : newmembers) {
                    member->typecheck(this);
                    
                    ASSERT(member!=nullptr, "Member is null");
                    ASSERT(!members.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    ASSERT(!instancemembers.Find(member->GetName()).IsValid(), "Symbol "+member->GetName()+" is already added.");
                    
                    instancemembers.Add(member);
                    member->SetParent(*this);
                }
            }
            
            void AddConstructors(std::initializer_list<Function::Overload*> elements) {
                for(auto element : elements) {
                    ASSERT((element != nullptr), "Given element cannot be nullptr", 1, 2);
                    ASSERT(element->HasReturnType() && element->GetReturnType()==this,
                           "Given constructor should return this ("+name+") type", 1, 2);
                    
                    constructor.AddOverload(*element);
                }
            }
            
            void AddConstructor(Function::Overload &element) {
                ASSERT(element.HasReturnType() && element.GetReturnType()==this,
                        "Given constructor should return this ("+name+") type", 1, 2);
                
                constructor.AddOverload(element);
            }
            
            void AddInheritance(const Type &type, Inheritance::ConversionFunction from, Inheritance::ConversionFunction to);
            
            Any GetDefaultValue() const {
                return defaultvalue;
            }
            
            bool IsReferenceType() const {
                return referencetype;
            }
            
            Data MorphTo(const Type &type, Data source, bool allowtypecast=true) const;
            
            MorphType CanMorphTo(const Type &type) const;
 
            bool operator ==(const Type &other) const {
                return this==&other;
            }
            
            bool operator ==(const Type *other) const {
                return this==other;
            }
            
            bool operator !=(const Type &other) const {
                return this!=&other;
            }
            
            bool operator !=(const Type *other) const {
                return this!=other;
            }
            
            operator const Type *() const {
                return this;
            }
 
            const Function::Overload *GetTypeCastingFrom(const Type *other, bool implicit=true) const {
                for(const auto &ctor : constructor.Overloads) {
                    if(ctor.Parameters.size()==1 && ctor.Parameters[0].GetType()==other && 
                        (!implicit || ctor.IsImplicit())
                    ) {
                        return &ctor;
                    }
                }
 
                return nullptr;
            }
 
            Data Construct(const std::vector<Data> &parameters) const;
 
            void Delete(const Data &obj) const {
                deleteobject(obj);
            }
            
            bool Compare(const Data &l, const Data &r) const;
            
            virtual std::string ToString(const Data &) const = 0;
            
            virtual Data Parse(const std::string &) const = 0;
            
            virtual void Assign(Data &l, const Data &r) const = 0;
            
            
            const Scripting::Function                           &Constructor;
            
            const std::map<const Type *, const Type *> &Parents;
            
            const std::map<const Type *, Inheritance> &InheritsFrom;
            
            const Containers::Hashmap<std::string, const Type, nullptr, std::map, String::CaseInsensitiveLess> &InheritedSymbols;
            
            const InstanceMemberList &InstanceMembers;
            
            TMP::RTTH &TypeInterface;
            
            virtual ~Type() {
                delete &TypeInterface;
                instancemembers.Destroy();
            }
            
        protected:
 
            virtual void deleteobject(const Data &) const=0;
            
            virtual bool compare(const Data &l, const Data &r) const { throw std::runtime_error("These elements cannot be compared"); }
            
            InstanceMemberList instancemembers;
 
            Any defaultvalue;
 
            Scripting::Function                         constructor;
            
            std::map<const Type *, Inheritance> inheritsfrom;
            
            Containers::Hashmap<std::string, const Type, nullptr, std::map, String::CaseInsensitiveLess> inheritedsymbols;
            
            std::map<const Type *, const Type *> parents;
            
            bool referencetype = false;
        };
        
        class Constant : public StaticMember {
        public:
            Constant(const std::string &name, const std::string &help, Data value) : 
            StaticMember(name, help), value(value) {
                ASSERT(value.IsValid(), "A constant cannot have an invalid value");
                this->value.MakeConstant();
            }
            
            virtual Data Get() const override final {
                return value;
            }
            
            virtual MemberType GetMemberType() const override final {
                return StaticMember::Constant;
            }
            
            const Type &GetType() const {
                return value.GetType();
            }
            
        protected:
            Data value;
        };
        
        inline std::ostream &operator <<(std::ostream &out, const Type &type) {
            out<<type.GetName();
            return out;
        }
        
        class EventType : public Type {
        public:
            EventType(const std::string &name, const std::string &help, const Any &defaultvalue, 
                  TMP::RTTH *typeinterface, const Type *ret, ParameterList parameters) : 
            Type(name, help, defaultvalue, typeinterface, true), Parameters(this->parameters), returntype(ret) {
                using std::swap;
                
                swap(parameters, this->parameters);
            }
            
            virtual MemberType GetMemberType() const override {
                return StaticMember::EventType;
            }
            
            virtual Data Get() const override final {
                return {Types::EventType(), dynamic_cast<const EventType*>(this), true, true};
            }
            
            bool HasReturnType() const {
                return returntype!=nullptr;
            }
            
            const Type &GetReturnType() const {
                ASSERT(returntype, "This event does not allow returns");
                
                return *returntype;
            }       
            
            virtual void Assign(Data &l, const Data &r) const override {
            }
            
            
            const ParameterList &Parameters;
            
        protected:
            ParameterList parameters;
            
            const Type *returntype;
        };
        
        class EnumType : public Type {
        public:         
            struct ElementInitializer {
                ElementInitializer(std::string name, std::string help, Any value) : name(name), help(help), value(value) { }
                
                std::string name;
                std::string help;
                Any value;
            };
            
            EnumType(const std::string& name, const std::string& help, 
                     const std::vector<ElementInitializer> &elements, 
                     TMP::RTTH* typeinterface) :
            Type(name, help, elements[0].value, typeinterface, false), Ordered(ordered)
            {
                for(const ElementInitializer &element : elements) {
                    auto elm=new Scripting::Constant(element.name, element.help, {this, element.value});
                    ordered.push_back(elm);
                    AddMember(elm);
                }
            }
            
            virtual MemberType GetMemberType() const override {
                return StaticMember::EnumType;
            }
            
            virtual Data Get() const override final {
                return {Types::EnumType(), dynamic_cast<const EnumType*>(this), true, true};
            }
            
            const std::vector<const Scripting::Constant*> &Ordered;
        
        protected:
            
            EnumType(const std::string& name, const std::string& help, Any defval,
            TMP::RTTH* typeinterface) :
            Type(name, help, defval, typeinterface, false), Ordered(ordered)
            { }
            
            void add(const ElementInitializer &element) {
                auto elm=new Scripting::Constant(element.name, element.help, {this, element.value});
                ordered.push_back(elm);
                AddMember(elm);
            }
            
        private:
            std::vector<const Scripting::Constant*> ordered;
            
        };
        
        class Library : public Namespace {
        public:
            Library(const std::string &name, const std::string &help) : Namespace(name, help) {
            }
            
            ~Library() {
            }
            
            virtual void SetParent(const Member &parent) override {
                Utils::ASSERT_FALSE("Cannot set parent of a library");
            }
        };
    }
}