diff options
37 files changed, 560 insertions, 509 deletions
diff --git a/src/core/XML.cpp b/src/core/XML.cpp index 9ca808d..722c490 100644 --- a/src/core/XML.cpp +++ b/src/core/XML.cpp @@ -123,7 +123,7 @@ namespace RttiTypes RttiBuilder<xml::Element>("XMLElement") .parent(&XMLNode) .composedOf(&XMLNode) - .property("name", {RttiTypes::String, + .property("name", {&RttiTypes::String, {[](const xml::Element *obj) { return Variant::fromString(obj->name); }}}); diff --git a/src/core/common/Argument.cpp b/src/core/common/Argument.cpp index 385bae1..bfe74a4 100644 --- a/src/core/common/Argument.cpp +++ b/src/core/common/Argument.cpp @@ -27,161 +27,161 @@ namespace ousia { /* Class Argument */ -Argument::Argument(std::string name, const Rtti &type, const Rtti &innerType, +Argument::Argument(std::string name, const Rtti *type, const Rtti *innerType, Variant defaultValue, bool hasDefaultValue) : name(std::move(name)), - type(&type), - innerType(&innerType), + type(type), + innerType(innerType), defaultValue(std::move(defaultValue)), hasDefaultValue(hasDefaultValue) { } -Argument::Argument(std::string name, const Rtti &type, Variant defaultValue) - : Argument(std::move(name), type, RttiTypes::None, defaultValue, true) +Argument::Argument(std::string name, const Rtti *type, Variant defaultValue) + : Argument(std::move(name), type, &RttiTypes::None, defaultValue, true) { } -Argument::Argument(std::string name, const Rtti &type) - : Argument(std::move(name), type, RttiTypes::None, nullptr, false) +Argument::Argument(std::string name, const Rtti *type) + : Argument(std::move(name), type, &RttiTypes::None, nullptr, false) { } Argument Argument::Any(std::string name) { - return Argument{name, RttiTypes::None, RttiTypes::None, nullptr, false}; + return Argument{name, &RttiTypes::None, &RttiTypes::None, nullptr, false}; } Argument Argument::Any(std::string name, Variant defaultValue) { - return Argument{name, RttiTypes::None, RttiTypes::None, defaultValue, true}; + return Argument{name, &RttiTypes::None, &RttiTypes::None, defaultValue, true}; } Argument Argument::Bool(std::string name) { - return Argument{name, RttiTypes::Bool}; + return Argument{name, &RttiTypes::Bool}; } Argument Argument::Bool(std::string name, Variant::boolType defaultValue) { - return Argument{name, RttiTypes::Bool, defaultValue}; + return Argument{name, &RttiTypes::Bool, defaultValue}; } Argument Argument::Int(std::string name) { - return Argument{name, RttiTypes::Int}; + return Argument{name, &RttiTypes::Int}; } Argument Argument::Int(std::string name, Variant::intType defaultValue) { - return Argument{name, RttiTypes::Int, defaultValue}; + return Argument{name, &RttiTypes::Int, defaultValue}; } Argument Argument::Double(std::string name) { - return Argument{name, RttiTypes::Double}; + return Argument{name, &RttiTypes::Double}; } Argument Argument::Double(std::string name, Variant::doubleType defaultValue) { - return Argument{name, RttiTypes::Double, defaultValue}; + return Argument{name, &RttiTypes::Double, defaultValue}; } Argument Argument::String(std::string name) { - return Argument{name, RttiTypes::String}; + return Argument{name, &RttiTypes::String}; } Argument Argument::String(std::string name, const Variant::stringType &defaultValue) { - return Argument{name, RttiTypes::String, Variant::fromString(defaultValue)}; + return Argument{name, &RttiTypes::String, Variant::fromString(defaultValue)}; } -Argument Argument::Object(std::string name, const Rtti &type) +Argument Argument::Object(std::string name, const Rtti *type) { - return Argument(std::move(name), type, RttiTypes::None, + return Argument(std::move(name), type, &RttiTypes::None, Variant::fromObject(nullptr), false); } -Argument Argument::Object(std::string name, const Rtti &type, std::nullptr_t) +Argument Argument::Object(std::string name, const Rtti *type, std::nullptr_t) { - return Argument(std::move(name), type, RttiTypes::None, + return Argument(std::move(name), type, &RttiTypes::None, Variant::fromObject(nullptr), true); } Argument Argument::Function(std::string name) { - return Argument(std::move(name), RttiTypes::Function); + return Argument(std::move(name), &RttiTypes::Function); } Argument Argument::Function(std::string name, Variant::functionType defaultValue) { - return Argument(std::move(name), RttiTypes::Function, + return Argument(std::move(name), &RttiTypes::Function, Variant::fromFunction(defaultValue)); } Argument Argument::Array(std::string name) { - return Argument(std::move(name), RttiTypes::Array); + return Argument(std::move(name), &RttiTypes::Array); } Argument Argument::Array(std::string name, const Variant::arrayType &defaultValue) { - return Argument(std::move(name), RttiTypes::Array, defaultValue); + return Argument(std::move(name), &RttiTypes::Array, defaultValue); } -Argument Argument::Array(std::string name, const Rtti &innerType) +Argument Argument::Array(std::string name, const Rtti *innerType) { - return Argument(std::move(name), RttiTypes::Array, innerType, nullptr, + return Argument(std::move(name), &RttiTypes::Array, innerType, nullptr, false); } -Argument Argument::Array(std::string name, const Rtti &innerType, +Argument Argument::Array(std::string name, const Rtti *innerType, const Variant::arrayType &defaultValue) { - return Argument(std::move(name), RttiTypes::Array, innerType, defaultValue, + return Argument(std::move(name), &RttiTypes::Array, innerType, defaultValue, true); } Argument Argument::Map(std::string name) { - return Argument(std::move(name), RttiTypes::Map); + return Argument(std::move(name), &RttiTypes::Map); } Argument Argument::Map(std::string name, const Variant::mapType &defaultValue) { - return Argument(std::move(name), RttiTypes::Map, defaultValue); + return Argument(std::move(name), &RttiTypes::Map, defaultValue); } -Argument Argument::Map(std::string name, const Rtti &innerType) +Argument Argument::Map(std::string name, const Rtti *innerType) { - return Argument(std::move(name), RttiTypes::Map, innerType, nullptr, false); + return Argument(std::move(name), &RttiTypes::Map, innerType, nullptr, false); } -Argument Argument::Map(std::string name, const Rtti &innerType, +Argument Argument::Map(std::string name, const Rtti *innerType, const Variant::mapType &defaultValue) { - return Argument(std::move(name), RttiTypes::Map, innerType, defaultValue, + return Argument(std::move(name), &RttiTypes::Map, innerType, defaultValue, true); } Argument Argument::Cardinality(std::string name) { - return Argument{name, RttiTypes::Cardinality}; + return Argument{name, &RttiTypes::Cardinality}; } Argument Argument::Cardinality(std::string name, Variant::cardinalityType defaultValue) { - return Argument{name, RttiTypes::Cardinality, defaultValue}; + return Argument{name, &RttiTypes::Cardinality, defaultValue}; } bool Argument::validate(Variant &var, Logger &logger) const { - if (!VariantConverter::convert(var, *type, *innerType, logger, + if (!VariantConverter::convert(var, type, innerType, logger, VariantConverter::Mode::SAFE)) { if (hasDefaultValue) { var = defaultValue; diff --git a/src/core/common/Argument.hpp b/src/core/common/Argument.hpp index ea68e3c..679b4a5 100644 --- a/src/core/common/Argument.hpp +++ b/src/core/common/Argument.hpp @@ -93,7 +93,7 @@ private: * @param hasDefault indicates whether the defaultValue actually should be * used. */ - Argument(std::string name, const Rtti &type, const Rtti &innerType, + Argument(std::string name, const Rtti *type, const Rtti *innerType, Variant defaultValue, bool hasDefault); /** @@ -105,7 +105,7 @@ private: * expected. * @param defaultValue is the default value to be used. */ - Argument(std::string name, const Rtti &type, Variant defaultValue); + Argument(std::string name, const Rtti *type, Variant defaultValue); /** * Private constructor used to build an argument describing a primitive type @@ -115,7 +115,7 @@ private: * @param variantType is the variant type of the argument that is to be * expected. */ - Argument(std::string name, const Rtti &type); + Argument(std::string name, const Rtti *type); public: /** @@ -230,7 +230,7 @@ public: * "isa" function returns true for the given type are be accepted. * @return a new Argument instance. */ - static Argument Object(std::string name, const Rtti &type); + static Argument Object(std::string name, const Rtti *type); /** * Named constructor for an object argument with default value. The default @@ -246,7 +246,7 @@ public: * cannot be stored. * @return a new Argument instance. */ - static Argument Object(std::string name, const Rtti &type, + static Argument Object(std::string name, const Rtti *type, std::nullptr_t defaultValue); /** @@ -303,7 +303,7 @@ public: * forced to be of this type. * @return a new Argument instance. */ - static Argument Array(std::string name, const Rtti &innerType); + static Argument Array(std::string name, const Rtti *innerType); /** * Named constructor for an array argument of objects of the given RTTI @@ -317,7 +317,7 @@ public: * @param defaultValue is the default value to be used in case this argument * is not supplied. */ - static Argument Array(std::string name, const Rtti &innerType, + static Argument Array(std::string name, const Rtti *innerType, const Variant::arrayType &defaultValue); /** @@ -352,7 +352,7 @@ public: * to be of this type. * @return a new Argument instance. */ - static Argument Map(std::string name, const Rtti &innerType); + static Argument Map(std::string name, const Rtti *innerType); /** * Named constructor for a map argument with default value and a given inner @@ -366,7 +366,7 @@ public: * is not supplied. * @return a new Argument instance. */ - static Argument Map(std::string name, const Rtti &innerType, + static Argument Map(std::string name, const Rtti *innerType, const Variant::mapType &defaultValue); /** diff --git a/src/core/common/Property.hpp b/src/core/common/Property.hpp index 10db869..546061c 100644 --- a/src/core/common/Property.hpp +++ b/src/core/common/Property.hpp @@ -67,21 +67,21 @@ struct PropertyType { * Outer type, may be any Rtti instance. If set to RttiTypes::None, any * outer type is acceptable. */ - const Rtti &type; + const Rtti *type; /** * Describes the inner type of the property used when the outer type is a * container type such as RttiTypes::Array or RttiTypes::Map. If set to * RttiTypes::None any inner type is acceptable. */ - const Rtti &innerType; + const Rtti *innerType; /** * Creates a new instance of the PropertyType class with both inner and * outer type being set to RttiTypes::None and thus allowing any type to be * represented by this property. */ - PropertyType() : type(RttiTypes::None), innerType(RttiTypes::None){}; + PropertyType() : type(&RttiTypes::None), innerType(&RttiTypes::None){}; /** * Creates a new instance of the PropertyType class with the given outer @@ -91,8 +91,8 @@ struct PropertyType { * be any Rtti instances or RttiTypes::None, in which case all types are * allowed. */ - PropertyType(const Rtti &type) - : type(type), innerType(RttiTypes::None){}; + PropertyType(const Rtti *type) + : type(type), innerType(&RttiTypes::None){}; /** * Creates a new instance of the PropertyType class with the given outer and @@ -105,7 +105,7 @@ struct PropertyType { * relevant if the outer type is set to a basic container type, namely * RttiTypes::Array or RttiTypes::Map. */ - PropertyType(const Rtti &type, const Rtti &innerType) + PropertyType(const Rtti *type, const Rtti *innerType) : type(type), innerType(innerType){}; }; @@ -396,7 +396,7 @@ public: * * @return the PropertyType instance describing the type of this property. */ - const PropertyType &getType() const { return *type; } + const PropertyType *getType() const { return type.get(); } /** * Returns the value of the property for the given object. @@ -454,7 +454,7 @@ public: * @param setter is a Setter for writing the described property for objects * of type T. */ - Property(const Rtti &type, const Getter<T> &getter, + Property(const Rtti *type, const Getter<T> &getter, const Setter<T> &setter = Setter<T>{}) : PropertyDescriptor( PropertyType{type}, @@ -477,7 +477,7 @@ public: * @param setter is a Setter for writing the described property for objects * of type T. */ - Property(const Rtti &type, const Rtti &innerType, + Property(const Rtti *type, const Rtti *innerType, const Getter<T> &getter, const Setter<T> &setter = Setter<T>{}) : PropertyDescriptor( PropertyType{type, innerType}, diff --git a/src/core/common/Rtti.cpp b/src/core/common/Rtti.cpp index acc98a7..7c353d5 100644 --- a/src/core/common/Rtti.cpp +++ b/src/core/common/Rtti.cpp @@ -34,14 +34,14 @@ void RttiStore::store(const std::type_info &native, const Rtti *rtti) table().emplace(std::type_index{native}, rtti); } -const Rtti &RttiStore::lookup(const std::type_info &native) +const Rtti *RttiStore::lookup(const std::type_info &native) { const auto &tbl = table(); auto it = tbl.find(std::type_index{native}); if (it == tbl.end()) { - return RttiTypes::None; + return &RttiTypes::None; } else { - return *(it->second); + return it->second; } } @@ -120,10 +120,10 @@ void Rtti::initialize() const } } -bool Rtti::isa(const Rtti &other) const +bool Rtti::isa(const Rtti *other) const { initialize(); - return parents.count(&other) > 0; + return parents.count(other) > 0; } bool Rtti::isOneOf(const RttiSet &others) const @@ -158,10 +158,10 @@ RttiSet Rtti::setIntersection(const RttiSet &s1, const RttiSet &s2) return res; } -bool Rtti::composedOf(const Rtti &other) const +bool Rtti::composedOf(const Rtti *other) const { initialize(); - return compositeTypes.count(&other) > 0; + return compositeTypes.count(other) > 0; } const RttiMethodMap &Rtti::getMethods() const diff --git a/src/core/common/Rtti.hpp b/src/core/common/Rtti.hpp index f371494..de9f3f6 100644 --- a/src/core/common/Rtti.hpp +++ b/src/core/common/Rtti.hpp @@ -127,7 +127,7 @@ public: * Looks up the type information stored for the given native type * information. */ - static const Rtti &lookup(const std::type_info &native); + static const Rtti *lookup(const std::type_info &native); }; /** @@ -381,7 +381,7 @@ public: * @return true if this type (directly or indirectly) has the given other * type as parent or equals the other type. */ - bool isa(const Rtti &other) const; + bool isa(const Rtti *other) const; /** * Returns true if this Rtti instance is one of the given types. @@ -421,7 +421,7 @@ public: * @param other is the other type for which should be checked whether this * type is directly or indirectly composed of it. */ - bool composedOf(const Rtti &other) const; + bool composedOf(const Rtti *other) const; /** * Returns all methods that are registered for this type (and the parent @@ -489,7 +489,7 @@ public: * @tparam T is the C++ type for which the type information should be returned. */ template <typename T> -inline const Rtti &typeOf() +inline const Rtti *typeOf() { return RttiStore::lookup(typeid(T)); } @@ -505,7 +505,7 @@ inline const Rtti &typeOf() * returned. */ template <typename T> -inline const Rtti &typeOf(const T &obj) +inline const Rtti *typeOf(const T &obj) { return RttiStore::lookup(typeid(obj)); } diff --git a/src/core/common/Variant.cpp b/src/core/common/Variant.cpp index 0c7fceb..836fed3 100644 --- a/src/core/common/Variant.cpp +++ b/src/core/common/Variant.cpp @@ -148,12 +148,12 @@ Variant::arrayType Variant::toArray() const { ExceptionLogger logger; Variant res{*this}; - VariantConverter::toArray(res, RttiTypes::None, logger, + VariantConverter::toArray(res, &RttiTypes::None, logger, VariantConverter::Mode::ALL); return res.asArray(); } -Variant::arrayType Variant::toArray(const Rtti &innerType) const +Variant::arrayType Variant::toArray(const Rtti *innerType) const { ExceptionLogger logger; Variant res{*this}; @@ -166,12 +166,12 @@ Variant::mapType Variant::toMap() const { ExceptionLogger logger; Variant res{*this}; - VariantConverter::toMap(res, RttiTypes::None, logger, + VariantConverter::toMap(res, &RttiTypes::None, logger, VariantConverter::Mode::ALL); return res.asMap(); } -Variant::mapType Variant::toMap(const Rtti &innerType) const +Variant::mapType Variant::toMap(const Rtti *innerType) const { ExceptionLogger logger; Variant res{*this}; @@ -190,34 +190,34 @@ Variant::cardinalityType Variant::toCardinality() const /* Type management */ -const Rtti &Variant::getRtti() const +const Rtti *Variant::getRtti() const { switch (meta.getType()) { case VariantType::NULLPTR: - return RttiTypes::Nullptr; + return &RttiTypes::Nullptr; case VariantType::BOOL: - return RttiTypes::Bool; + return &RttiTypes::Bool; case VariantType::INT: - return RttiTypes::Int; + return &RttiTypes::Int; case VariantType::DOUBLE: - return RttiTypes::Double; + return &RttiTypes::Double; case VariantType::STRING: case VariantType::MAGIC: - return RttiTypes::String; + return &RttiTypes::String; case VariantType::ARRAY: - return RttiTypes::Array; + return &RttiTypes::Array; case VariantType::MAP: - return RttiTypes::Map; + return &RttiTypes::Map; case VariantType::CARDINALITY: - return RttiTypes::Cardinality; + return &RttiTypes::Cardinality; case VariantType::FUNCTION: - return RttiTypes::Function; + return &RttiTypes::Function; case VariantType::OBJECT: { Variant::objectType o = asObject(); - return (o == nullptr) ? RttiTypes::Nullptr : o->type(); + return (o == nullptr) ? &RttiTypes::Nullptr : o->type(); } } - return RttiTypes::None; + return &RttiTypes::None; } /* Output stream operators */ diff --git a/src/core/common/Variant.hpp b/src/core/common/Variant.hpp index 76f4506..6eae7e1 100644 --- a/src/core/common/Variant.hpp +++ b/src/core/common/Variant.hpp @@ -929,7 +929,7 @@ public: * to. * @return the value of the variant as array. */ - arrayType toArray(const Rtti &innerType) const; + arrayType toArray(const Rtti *innerType) const; /** * Returns the value of the Variant as map. @@ -946,7 +946,7 @@ public: * to. * @return the value of the variant as map. */ - mapType toMap(const Rtti &innerType) const; + mapType toMap(const Rtti *innerType) const; /** * Returns the value of the Variant as cardinality. @@ -1125,7 +1125,7 @@ public: * or RttiTypes::Function or -- in case an object is stored inside the * variant -- the Rtti of that object. */ - const Rtti &getRtti() const; + const Rtti *getRtti() const; /** * Returns the name of the given variant type as C-style string. diff --git a/src/core/common/VariantConverter.cpp b/src/core/common/VariantConverter.cpp index 29b4ef3..271fe75 100644 --- a/src/core/common/VariantConverter.cpp +++ b/src/core/common/VariantConverter.cpp @@ -305,7 +305,7 @@ bool VariantConverter::toString(Variant &var, Logger &logger, Mode mode) std::stringstream ss; ss << "<object " << obj.get(); if (obj.get() != nullptr) { - ss << " (" << obj->type().name << ")"; + ss << " (" << obj->type()->name << ")"; } ss << ">"; var = ss.str().c_str(); @@ -330,7 +330,7 @@ bool VariantConverter::toString(Variant &var, Logger &logger, Mode mode) return false; } -bool VariantConverter::toArray(Variant &var, const Rtti &innerType, +bool VariantConverter::toArray(Variant &var, const Rtti *innerType, Logger &logger, Mode mode) { // If unsafe conversions are allowed, encapsulate the given variant in an @@ -343,7 +343,7 @@ bool VariantConverter::toArray(Variant &var, const Rtti &innerType, if (var.isArray()) { // If no specific inner type is given, conversion is successful at this // point - if (&innerType == &RttiTypes::None) { + if (innerType == &RttiTypes::None) { return true; } @@ -351,7 +351,7 @@ bool VariantConverter::toArray(Variant &var, const Rtti &innerType, // failures to do so bool res = true; for (Variant &v : var.asArray()) { - res = convert(v, innerType, RttiTypes::None, logger, mode) & res; + res = convert(v, innerType, &RttiTypes::None, logger, mode) & res; } return res; } @@ -362,14 +362,14 @@ bool VariantConverter::toArray(Variant &var, const Rtti &innerType, return false; } -bool VariantConverter::toMap(Variant &var, const Rtti &innerType, +bool VariantConverter::toMap(Variant &var, const Rtti *innerType, Logger &logger, Mode mode) { // Make sure the variant is a map if (var.isMap()) { // If no specific inner type is given, conversion is successful at this // point - if (&innerType == &RttiTypes::None) { + if (innerType == &RttiTypes::None) { return true; } @@ -377,7 +377,7 @@ bool VariantConverter::toMap(Variant &var, const Rtti &innerType, // all failures to do so bool res = true; for (auto &e : var.asMap()) { - res = convert(e.second, innerType, RttiTypes::None, logger, mode) & + res = convert(e.second, innerType, &RttiTypes::None, logger, mode) & res; } return res; @@ -517,14 +517,14 @@ bool VariantConverter::toFunction(Variant &var, Logger &logger) return false; } -bool VariantConverter::convert(Variant &var, const Rtti &type, - const Rtti &innerType, Logger &logger, Mode mode) +bool VariantConverter::convert(Variant &var, const Rtti *type, + const Rtti *innerType, Logger &logger, Mode mode) { // Check for simple Variant types - if (&type == &RttiTypes::None) { + if (type == &RttiTypes::None) { return true; // Everything is fine if no specific type was // requested - } else if (&type == &RttiTypes::Nullptr) { + } else if (type == &RttiTypes::Nullptr) { // Make sure the variant is set to null if (!var.isNull()) { logger.error(msgUnexpectedType(var, VariantType::NULLPTR)); @@ -532,21 +532,21 @@ bool VariantConverter::convert(Variant &var, const Rtti &type, return false; } return true; - } else if (&type == &RttiTypes::Bool) { + } else if (type == &RttiTypes::Bool) { return toBool(var, logger, mode); - } else if (&type == &RttiTypes::Int) { + } else if (type == &RttiTypes::Int) { return toInt(var, logger, mode); - } else if (&type == &RttiTypes::Double) { + } else if (type == &RttiTypes::Double) { return toDouble(var, logger, mode); - } else if (&type == &RttiTypes::String) { + } else if (type == &RttiTypes::String) { return toString(var, logger, mode); - } else if (&type == &RttiTypes::Array) { + } else if (type == &RttiTypes::Array) { return toArray(var, innerType, logger, mode); - } else if (&type == &RttiTypes::Map) { + } else if (type == &RttiTypes::Map) { return toMap(var, innerType, logger, mode); - } else if (&type == &RttiTypes::Cardinality) { + } else if (type == &RttiTypes::Cardinality) { return toCardinality(var, logger, mode); - } else if (&type == &RttiTypes::Function) { + } else if (type == &RttiTypes::Function) { return toFunction(var, logger); } @@ -559,19 +559,19 @@ bool VariantConverter::convert(Variant &var, const Rtti &type, } // Make sure the object type is correct - if (!var.getRtti().isa(type)) { - logger.error(std::string("Expected object of type ") + type.name + - " but got object of type " + var.getRtti().name); + if (!var.getRtti()->isa(type)) { + logger.error(std::string("Expected object of type ") + type->name + + " but got object of type " + var.getRtti()->name); var.setObject(nullptr); return false; } return true; } -bool VariantConverter::convert(Variant &var, const Rtti &type, Logger &logger, +bool VariantConverter::convert(Variant &var, const Rtti *type, Logger &logger, Mode mode) { - return convert(var, type, RttiTypes::None, logger, mode); + return convert(var, type, &RttiTypes::None, logger, mode); } } diff --git a/src/core/common/VariantConverter.hpp b/src/core/common/VariantConverter.hpp index 92cc40a..26278eb 100644 --- a/src/core/common/VariantConverter.hpp +++ b/src/core/common/VariantConverter.hpp @@ -161,7 +161,7 @@ public: * @return true if the operation was successful, false otherwise. In any * case the input/output parameter "var" will have the requested type. */ - static bool toArray(Variant &var, const Rtti &innerType, Logger &logger, + static bool toArray(Variant &var, const Rtti *innerType, Logger &logger, Mode mode = Mode::SAFE); /** @@ -180,7 +180,7 @@ public: * @return true if the operation was successful, false otherwise. In any * case the input/output parameter "var" will have the requested type. */ - static bool toMap(Variant &var, const Rtti &innerType, Logger &logger, + static bool toMap(Variant &var, const Rtti *innerType, Logger &logger, Mode mode = Mode::SAFE); /** @@ -242,7 +242,7 @@ public: * @return true if the operation was successful, false otherwise. In any * case the input/output parameter "var" will have the requested type. */ - static bool convert(Variant &var, const Rtti &type, const Rtti &innerType, + static bool convert(Variant &var, const Rtti *type, const Rtti *innerType, Logger &logger, Mode mode = Mode::SAFE); /** @@ -261,7 +261,7 @@ public: * @return true if the operation was successful, false otherwise. In any * case the input/output parameter "var" will have the requested type. */ - static bool convert(Variant &var, const Rtti &type, Logger &logger, + static bool convert(Variant &var, const Rtti *type, Logger &logger, Mode mode = Mode::SAFE); }; } diff --git a/src/core/managed/Managed.cpp b/src/core/managed/Managed.cpp index b282427..64e287d 100644 --- a/src/core/managed/Managed.cpp +++ b/src/core/managed/Managed.cpp @@ -76,12 +76,12 @@ bool Managed::unregisterEvent(EventType type, EventHandler handler, bool Managed::triggerEvent(Event &ev) { return mgr.triggerEvent(this, ev); } -const Rtti &Managed::type() const { return typeOf(*this); } +const Rtti *Managed::type() const { return typeOf(*this); } -bool Managed::isa(const Rtti &t) const { return type().isa(t); } +bool Managed::isa(const Rtti *t) const { return type()->isa(t); } -bool Managed::composedOf(const Rtti &t) const +bool Managed::composedOf(const Rtti *t) const { - return type().composedOf(t); + return type()->composedOf(t); } } diff --git a/src/core/managed/Managed.hpp b/src/core/managed/Managed.hpp index 7c43527..4784e46 100644 --- a/src/core/managed/Managed.hpp +++ b/src/core/managed/Managed.hpp @@ -245,7 +245,7 @@ public: * @return a reference to the registered Rtti for this particular * Managed class. */ - const Rtti &type() const; + const Rtti *type() const; /** * Returns true if this Managed instance is of the type described by the @@ -255,7 +255,7 @@ public: * class is of the given type or one of the registered parent types is of * the given type. */ - bool isa(const Rtti &t) const; + bool isa(const Rtti *t) const; /** * Returns true if this Managed instance may contain instances of the type @@ -264,7 +264,7 @@ public: * @param true if the Rtti registered for this particular Managed class * may contain instance of the given type. */ - bool composedOf(const Rtti &t) const; + bool composedOf(const Rtti *t) const; }; /** diff --git a/src/core/managed/Manager.cpp b/src/core/managed/Manager.cpp index 2e0b882..ee4da5f 100644 --- a/src/core/managed/Manager.cpp +++ b/src/core/managed/Manager.cpp @@ -199,7 +199,7 @@ void Manager::deleteRef(Managed *tar, Managed *src, bool all) std::cerr << "\x1b[41;30mManager:\x1b[0m A managed object contains a rooted reference, " "this may cause memory leaks!" << std::endl; std::cerr << "\x1b[41;30mManager:\x1b[0m Referenced object is " << tar << " of type " - << tar->type().name << std::endl; + << tar->type()->name << std::endl; } #endif @@ -595,13 +595,13 @@ void Manager::exportGraphviz(const char *filename) : std::vector<EventHandlerDescriptor>{}; // Read type information and Node name (if available) - const Rtti &type = objectPtr->type(); - const std::string &typeName = type.name; + const Rtti *type = objectPtr->type(); + const std::string &typeName = type->name; // Fetch the name of the object if the object has a "name" property std::string name; - if (type.hasProperty("name")) { - name = type.getProperty("name")->get(objectPtr).toString(); + if (type->hasProperty("name")) { + name = type->getProperty("name")->get(objectPtr).toString(); } // Print the node @@ -662,7 +662,7 @@ void Manager::exportGraphviz(const char *filename) while (edgeCount > 0) { // Get the type of the target element uintptr_t pTar = reinterpret_cast<uintptr_t>(e.first); - const Rtti &typeTar = e.first->type(); + const Rtti *typeTar = e.first->type(); // Get some information about the edge std::string port = ""; @@ -679,7 +679,7 @@ void Manager::exportGraphviz(const char *filename) } } } - if (et == EdgeType::NORMAL && type.composedOf(typeTar)) { + if (et == EdgeType::NORMAL && type->composedOf(typeTar)) { et = EdgeType::AGGREGATE; } diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp index b981c26..de73bb8 100644 --- a/src/core/model/Document.cpp +++ b/src/core/model/Document.cpp @@ -77,7 +77,7 @@ int DocumentEntity::getFieldDescriptorIndex( void DocumentEntity::invalidateSubInstance() { - if (subInst->isa(RttiTypes::StructuredEntity)) { + if (subInst->isa(&RttiTypes::StructuredEntity)) { subInst.cast<StructuredEntity>()->invalidate(); } else { subInst.cast<AnnotationEntity>()->invalidate(); @@ -107,7 +107,7 @@ void DocumentEntity::setDescriptor(Handle<Descriptor> d) descriptor = subInst->acquire(d); // get the effective field descriptors in the descriptor. NodeVector<FieldDescriptor> fieldDescs; - if (descriptor->isa(RttiTypes::StructuredClass)) { + if (descriptor->isa(&RttiTypes::StructuredClass)) { fieldDescs = descriptor.cast<StructuredClass>()->getEffectiveFieldDescriptors(); } else { @@ -149,7 +149,7 @@ bool DocumentEntity::doValidate(Logger &logger) const * overridden in the subclasses. */ NodeVector<FieldDescriptor> fieldDescs; - if (descriptor->isa(RttiTypes::StructuredClass)) { + if (descriptor->isa(&RttiTypes::StructuredClass)) { fieldDescs = descriptor.cast<StructuredClass>()->getEffectiveFieldDescriptors(); } else { @@ -181,7 +181,7 @@ bool DocumentEntity::doValidate(Logger &logger) const continue; } // if we are here we know that exactly one child exists. - if (!fields[f][0]->isa(RttiTypes::DocumentPrimitive)) { + if (!fields[f][0]->isa(&RttiTypes::DocumentPrimitive)) { logger.error(std::string("Primitive Field \"") + fieldDescs[f]->getName() + "\" has non primitive content!", @@ -243,11 +243,11 @@ bool DocumentEntity::doValidate(Logger &logger) const *child); valid = false; } - if (child->isa(RttiTypes::Anchor)) { + if (child->isa(&RttiTypes::Anchor)) { // Anchors are uninteresting and can be ignored. continue; } - if (child->isa(RttiTypes::DocumentPrimitive)) { + if (child->isa(&RttiTypes::DocumentPrimitive)) { logger.error(std::string("Non-primitive Field \"") + fieldDescs[f]->getName() + "\" had primitive content!", @@ -344,7 +344,7 @@ void DocumentEntity::addStructureNode(Handle<StructureNode> s, const int &i) if (par != subInst) { // if a previous parent existed, remove the StructureNode from it if (par != nullptr) { - if (par->isa(RttiTypes::StructuredEntity)) { + if (par->isa(&RttiTypes::StructuredEntity)) { par.cast<StructuredEntity>()->removeStructureNode(s); } else { par.cast<AnnotationEntity>()->removeStructureNode(s); @@ -464,9 +464,9 @@ bool StructureNode::doValidate(Logger &logger) const logger.error("The parent is not set!", *this); valid = false; } - if (!getParent()->isa(RttiTypes::StructuredEntity) && - !getParent()->isa(RttiTypes::AnnotationEntity) && - !getParent()->isa(RttiTypes::Document)) { + if (!getParent()->isa(&RttiTypes::StructuredEntity) && + !getParent()->isa(&RttiTypes::AnnotationEntity) && + !getParent()->isa(&RttiTypes::Document)) { logger.error("The parent does not have a valid type!", *this); valid = false; } @@ -477,9 +477,9 @@ StructureNode::StructureNode(Manager &mgr, std::string name, Handle<Node> parent, const std::string &fieldName) : Node(mgr, std::move(name), parent) { - if (parent->isa(RttiTypes::StructuredEntity)) { + if (parent->isa(&RttiTypes::StructuredEntity)) { parent.cast<StructuredEntity>()->addStructureNode(this, fieldName); - } else if (parent->isa(RttiTypes::AnnotationEntity)) { + } else if (parent->isa(&RttiTypes::AnnotationEntity)) { parent.cast<AnnotationEntity>()->addStructureNode(this, fieldName); } else { throw OusiaException("The proposed parent was no DocumentEntity!"); @@ -552,7 +552,7 @@ bool AnnotationEntity::doValidate(Logger &logger) const if (getParent() == nullptr) { logger.error("The parent is not set!", *this); valid = false; - } else if (!getParent()->isa(RttiTypes::Document)) { + } else if (!getParent()->isa(&RttiTypes::Document)) { logger.error("The parent is not a document!", *this); valid = false; } else { @@ -640,7 +640,7 @@ bool Document::doValidate(Logger &logger) const void Document::doReference(Handle<Node> node) { - if (node->isa(RttiTypes::Domain)) { + if (node->isa(&RttiTypes::Domain)) { referenceDomain(node.cast<Domain>()); } } @@ -706,12 +706,12 @@ Rooted<AnnotationEntity> Document::createChildAnnotation( bool Document::hasChild(Handle<StructureNode> s) const { Rooted<Managed> parent = s->getParent(); - if (parent->isa(RttiTypes::StructureNode)) { + if (parent->isa(&RttiTypes::StructureNode)) { return hasChild(parent.cast<StructureNode>()); - } else if (parent->isa(RttiTypes::AnnotationEntity)) { + } else if (parent->isa(&RttiTypes::AnnotationEntity)) { Handle<AnnotationEntity> a = parent.cast<AnnotationEntity>(); return this == a->getParent(); - } else if (parent->isa(RttiTypes::Document)) { + } else if (parent->isa(&RttiTypes::Document)) { return this == parent; } return false; diff --git a/src/core/model/Domain.cpp b/src/core/model/Domain.cpp index 7d5a76e..55f05b3 100644 --- a/src/core/model/Domain.cpp +++ b/src/core/model/Domain.cpp @@ -61,7 +61,7 @@ bool FieldDescriptor::doValidate(Logger &logger) const if (getParent() == nullptr) { logger.error("This field has no parent!", *this); valid = false; - } else if (!getParent()->isa(RttiTypes::Descriptor)) { + } else if (!getParent()->isa(&RttiTypes::Descriptor)) { logger.error("The parent of this field is not a descriptor!", *this); valid = false; } @@ -142,7 +142,7 @@ bool Descriptor::doValidate(Logger &logger) const if (getParent() == nullptr) { logger.error("This Descriptor has no parent!", *this); valid = false; - } else if (!getParent()->isa(RttiTypes::Domain)) { + } else if (!getParent()->isa(&RttiTypes::Domain)) { logger.error("The parent of this Descriptor is not a Domain!", *this); valid = false; } @@ -180,7 +180,7 @@ bool Descriptor::continuePath(Handle<StructuredClass> target, // use recursive depth-first search from the top to reach the given child // get the list of effective FieldDescriptors. NodeVector<FieldDescriptor> fields; - if (isa(RttiTypes::StructuredClass)) { + if (isa(&RttiTypes::StructuredClass)) { const StructuredClass *tis = static_cast<const StructuredClass *>(this); fields = tis->getEffectiveFieldDescriptors(); } else { @@ -212,7 +212,7 @@ bool Descriptor::continuePath(Handle<StructuredClass> target, } } - if (isa(RttiTypes::StructuredClass)) { + if (isa(&RttiTypes::StructuredClass)) { const StructuredClass *tis = static_cast<const StructuredClass *>(this); // if this is a StructuredClass we also can call the subclasses. for (auto &c : tis->getSubclasses()) { @@ -489,7 +489,7 @@ bool Domain::doValidate(Logger &logger) const void Domain::doReference(Handle<Node> node) { - if (node->isa(RttiTypes::Domain)) { + if (node->isa(&RttiTypes::Domain)) { referenceTypesystem(node.cast<Typesystem>()); } } diff --git a/src/core/model/Node.cpp b/src/core/model/Node.cpp index 65f093f..39ee2e4 100644 --- a/src/core/model/Node.cpp +++ b/src/core/model/Node.cpp @@ -62,7 +62,7 @@ public: /** * Type of the node that was requested for resolution. */ - const Rtti &type; + const Rtti *type; /** * Actual path (name pattern) that was requested for resolution. @@ -86,7 +86,7 @@ public: * @param path is a const reference to the actual path that should be * resolved. */ - SharedResolutionState(const Rtti &type, + SharedResolutionState(const Rtti *type, const std::vector<std::string> &path) : type(type), path(path) { @@ -182,35 +182,86 @@ public: /** * Returns true if the given type matches the type given in the query. * + * @param type is the type that should be checked. * @return true if the type matches, false otherwise. */ - bool typeMatches(const Rtti &type) { return type.isa(shared.type); } + bool typeMatches(const Rtti *type) { return type->isa(shared.type); } - bool canContainType(const Rtti &type) + /** + * Returns true if the given type can contain the node that is currently + * being resolved. + * + * @param type is the type that should be checked. + * @return true if the given type can contain the node that is currently + * begin resolved, false otherwise. + */ + bool canContainType(const Rtti *type) + { + return type->composedOf(shared.type); + } + + /** + * Returns true if the resolution process is still allowed to follow + * references. This is only the case if we are at the beginning of the + * resolution process and have not entered another start tree. + * + * @return true if references can still be followed, false if only composita + * may be examined. + */ + bool canFollowReferences() { - return type.composedOf(shared.type); + return idx == 0 && inStartTree && !foundCompositum; } + /** + * Returns true if we can still descend into new composita. This is only + * the case if we have not yet descended into another compositum beforehand. + * + * @return true if composita can be followed, false otherwise. + */ + bool canFollowComposita() { return idx == 0; } + + /** + * Returns the number of matching nodes that were found until now. + * + * @return the number of matching nodes. + */ + size_t resultCount() { return shared.result.size(); } + + /** + * Returns the name that is currently being search for (at the current path + * position). + * + * @return the current name. + */ const std::string ¤tName() { return shared.path[idx]; } + /** + * Returns a new ResolutionState instance where the path position is moved + * on by one element. + * + * @return a copy of the current ResolutionState instance with the path + * position being incremented by one. + */ ResolutionState advance() { return ResolutionState{shared, resolutionRoot, idx + 1, false}; } + /** + * Forks current ResolutionState instance with the resolution starting at + * the given node. This function is used when a reference is being followed. + * + * @param newResolutionRoot is the root node of the new subtree in which + * resolution takes place. + * @return a copy of this ResolutionState instance with the resolution root + * begin set to the new root instance and the path position being set to + * zero. + */ ResolutionState fork(Node *newResolutionRoot) { return ResolutionState{shared, newResolutionRoot, 0, false}; } - - bool canFollowReferences() - { - return idx == 0 && inStartTree && !foundCompositum; - } - - bool canFollowComposita() { return idx == 0; } - - size_t resultCount() { return shared.result.size(); } }; /* Class ResolutionResult */ @@ -329,7 +380,7 @@ bool Node::continueResolveReference(Handle<Node> h, ResolutionState &state) } std::vector<ResolutionResult> Node::resolve( - const Rtti &type, const std::vector<std::string> &path) + const Rtti *type, const std::vector<std::string> &path) { // Create the state variables SharedResolutionState sharedState(type, path); @@ -344,7 +395,7 @@ std::vector<ResolutionResult> Node::resolve( return sharedState.result; } -std::vector<ResolutionResult> Node::resolve(const Rtti &type, +std::vector<ResolutionResult> Node::resolve(const Rtti *type, const std::string &name) { // Place the name in a vector and call the corresponding resolve function @@ -359,7 +410,7 @@ bool Node::checkDuplicate(Handle<Node> elem, if (!names.emplace(name).second) { logger.error(std::string("Element with name \"") + name + std::string("\" defined multiple times in parent ") + - type().name + std::string(" \"") + + type()->name + std::string(" \"") + Utils::join(path(), ".") + std::string("\""), *elem); return false; @@ -398,7 +449,7 @@ bool Node::doValidate(Logger &logger) const { return true; } bool Node::validateName(Logger &logger) const { if (!Utils::isIdentifier(name)) { - logger.error(type().name + std::string(" name \"") + name + + logger.error(type()->name + std::string(" name \"") + name + std::string("\" is not a valid identifier"), this); return false; @@ -421,7 +472,7 @@ bool Node::validateIsAcyclic(const std::string &name, for (size_t i = 0; i < path.size(); i++) { auto node = path[i]; const std::string &name = node->getName(); - const std::string &typeName = node->type().name; + const std::string &typeName = node->type()->name; const std::string suffix = i == path.size() - 1 ? std::string{" (this node closes the cycle):"} @@ -517,14 +568,14 @@ void Node::setParent(Handle<Node> p) namespace RttiTypes { const Rtti Node = RttiBuilder<ousia::Node>("Node") - .property("name", {RttiTypes::String, + .property("name", {&RttiTypes::String, {[](const ousia::Node *obj) { return Variant::fromString(obj->getName()); }}, {[](const Variant &value, ousia::Node *obj) { obj->setName(value.asString()); }}}) - .property("parent", {Node, + .property("parent", {&Node, {[](const ousia::Node *obj) { return Variant::fromObject(obj->getParent()); }}}); diff --git a/src/core/model/Node.hpp b/src/core/model/Node.hpp index 61bf418..fe8db16 100644 --- a/src/core/model/Node.hpp +++ b/src/core/model/Node.hpp @@ -545,7 +545,7 @@ public: * @return a vector containing ResolutionResult structures which describe * the resolved elements. */ - std::vector<ResolutionResult> resolve(const Rtti &type, + std::vector<ResolutionResult> resolve(const Rtti *type, const std::vector<std::string> &path); /** @@ -557,7 +557,7 @@ public: * @return a vector containing ResolutionResult structures which describe * the resolved elements. */ - std::vector<ResolutionResult> resolve(const Rtti &type, + std::vector<ResolutionResult> resolve(const Rtti *type, const std::string &name); /** diff --git a/src/core/model/Project.cpp b/src/core/model/Project.cpp index 31530f3..f7dab8a 100644 --- a/src/core/model/Project.cpp +++ b/src/core/model/Project.cpp @@ -42,7 +42,7 @@ void Project::doResolve(ResolutionState &state){ } void Project::doReference(Handle<Node> node) { - if (node->isa(RttiTypes::Document)) { + if (node->isa(&RttiTypes::Document)) { referenceDocument(node.cast<Document>()); } } diff --git a/src/core/model/RootNode.cpp b/src/core/model/RootNode.cpp index 821c50c..642ec14 100644 --- a/src/core/model/RootNode.cpp +++ b/src/core/model/RootNode.cpp @@ -24,10 +24,10 @@ namespace ousia { void RootNode::reference(Handle<Node> node) { - if (!node->type().isOneOf(getReferenceTypes())) { + if (!node->type()->isOneOf(getReferenceTypes())) { throw OusiaException( - std::string("Node with type ") + node->type().name + - std::string(" cannot be referenced in a ") + type().name); + std::string("Node with type ") + node->type()->name + + std::string(" cannot be referenced in a ") + type()->name); } doReference(node); } diff --git a/src/core/model/Typesystem.cpp b/src/core/model/Typesystem.cpp index bd5e615..fb99f87 100644 --- a/src/core/model/Typesystem.cpp +++ b/src/core/model/Typesystem.cpp @@ -648,13 +648,13 @@ bool ArrayType::doCheckIsa(Handle<const Type> type) const Handle<const Type> t2{type}; // Unwrap the array types until only the innermost type is left - while (t1->isa(RttiTypes::ArrayType) && t2->isa(RttiTypes::ArrayType)) { + while (t1->isa(&RttiTypes::ArrayType) && t2->isa(&RttiTypes::ArrayType)) { t1 = t1.cast<const ArrayType>()->innerType; t2 = t2.cast<const ArrayType>()->innerType; } // Abort if only one of the to types is an array type - if (t1->isa(RttiTypes::ArrayType) || t2->isa(RttiTypes::ArrayType)) { + if (t1->isa(&RttiTypes::ArrayType) || t2->isa(&RttiTypes::ArrayType)) { return false; } @@ -725,7 +725,7 @@ bool Typesystem::doValidate(Logger &logger) const void Typesystem::doReference(Handle<Node> node) { - if (node->isa(RttiTypes::Typesystem)) { + if (node->isa(&RttiTypes::Typesystem)) { referenceTypesystem(node.cast<Typesystem>()); } } diff --git a/src/core/parser/ParserScope.cpp b/src/core/parser/ParserScope.cpp index b97dabd..9c0b729 100644 --- a/src/core/parser/ParserScope.cpp +++ b/src/core/parser/ParserScope.cpp @@ -33,7 +33,7 @@ ParserScopeBase::ParserScopeBase(const NodeVector<Node> &nodes) : nodes(nodes) { } -Rooted<Node> ParserScopeBase::resolve(const Rtti &type, +Rooted<Node> ParserScopeBase::resolve(const Rtti *type, const std::vector<std::string> &path, Logger &logger) { @@ -74,7 +74,7 @@ std::vector<Rtti const *> ParserScopeBase::getStackTypeSignature() const std::vector<Rtti const *> res; res.reserve(nodes.size()); for (size_t i = 0; i < nodes.size(); i++) { - res.push_back(&(nodes[i]->type())); + res.push_back(nodes[i]->type()); } return res; } @@ -86,7 +86,7 @@ Rooted<Node> ParserScopeBase::select(RttiSet types, int maxDepth) minDepth = static_cast<ssize_t>(nodes.size()) - (maxDepth + 1); } for (ssize_t i = nodes.size() - 1; i >= minDepth; i--) { - if (nodes[i]->type().isOneOf(types)) { + if (nodes[i]->type()->isOneOf(types)) { return nodes[i]; } } @@ -113,7 +113,7 @@ Rooted<Node> ParserScopeBase::selectOrThrow(RttiSet types, int maxDepth) DeferredResolution::DeferredResolution(const NodeVector<Node> &nodes, const std::vector<std::string> &path, - const Rtti &type, + const Rtti *type, ResolutionResultCallback resultCallback, Handle<Node> owner) : scope(nodes), @@ -179,7 +179,7 @@ bool ParserScope::checkUnwound(Logger &logger) const MessageMode::NO_CONTEXT); for (size_t i = topLevelDepth + 1; i < nodes.size(); i++) { logger.note(std::string("Element of interal type ") + - nodes[i]->type().name + + nodes[i]->type()->name + std::string(" defined here:"), *nodes[i]); } @@ -270,7 +270,7 @@ bool ParserScope::getFlag(ParserFlag flag) return false; } -bool ParserScope::resolve(const Rtti &type, +bool ParserScope::resolve(const Rtti *type, const std::vector<std::string> &path, Handle<Node> owner, Logger &logger, ResolutionImposterCallback imposterCallback, @@ -283,7 +283,7 @@ bool ParserScope::resolve(const Rtti &type, return true; } -bool ParserScope::resolve(const Rtti &type, +bool ParserScope::resolve(const Rtti *type, const std::vector<std::string> &path, Handle<Node> owner, Logger &logger, ResolutionResultCallback resultCallback) @@ -340,7 +340,7 @@ bool ParserScope::resolveType(const std::vector<std::string> &path, } // Requested type is not an array, call the usual resolve function - return resolve(RttiTypes::Type, path, owner, logger, resultCallback); + return resolve(&RttiTypes::Type, path, owner, logger, resultCallback); } bool ParserScope::resolveType(const std::string &name, Handle<Node> owner, @@ -359,7 +359,7 @@ bool ParserScope::resolveValue(Variant &data, Handle<Type> type, const Type *innerType) mutable -> Type::MagicCallbackResult { // Try to resolve the node Rooted<Constant> constant = - ParserScopeBase::resolve(RttiTypes::Constant, + ParserScopeBase::resolve(&RttiTypes::Constant, Utils::split(innerData.asMagic(), '.'), logger).cast<Constant>(); @@ -464,7 +464,7 @@ bool ParserScope::performDeferredResolution(Logger &logger) // succeed. for (auto &failed : deferred) { failed.fail(logger); - logger.error(std::string("Could not resolve ") + failed.type.name + + logger.error(std::string("Could not resolve ") + failed.type->name + std::string(" \"") + Utils::join(failed.path, ".") + std::string("\""), *failed.owner); diff --git a/src/core/parser/ParserScope.hpp b/src/core/parser/ParserScope.hpp index 1de1592..bd6a29f 100644 --- a/src/core/parser/ParserScope.hpp +++ b/src/core/parser/ParserScope.hpp @@ -103,7 +103,7 @@ public: * @return a reference at a resolved node or nullptr if no node could be * found. */ - Rooted<Node> resolve(const Rtti &type, const std::vector<std::string> &path, + Rooted<Node> resolve(const Rtti *type, const std::vector<std::string> &path, Logger &logger); /** @@ -167,7 +167,7 @@ public: template <class T> Rooted<T> select(int maxDepth = -1) { - return select(RttiSet{&typeOf<T>()}, maxDepth).cast<T>(); + return select(RttiSet{typeOf<T>()}, maxDepth).cast<T>(); } /** @@ -195,7 +195,7 @@ public: template <class T> Rooted<T> selectOrThrow(int maxDepth = -1) { - return selectOrThrow(RttiSet{&typeOf<T>()}, maxDepth).cast<T>(); + return selectOrThrow(RttiSet{typeOf<T>()}, maxDepth).cast<T>(); } }; @@ -227,7 +227,7 @@ public: /** * Reference at the type of the object that should be resolved. */ - const Rtti &type; + const Rtti *type; /** * Node for which the resolution is taking place. @@ -248,7 +248,7 @@ public: * @param owner is the node for which the resolution takes place. */ DeferredResolution(const NodeVector<Node> &nodes, - const std::vector<std::string> &path, const Rtti &type, + const std::vector<std::string> &path, const Rtti *type, ResolutionResultCallback resultCallback, Handle<Node> owner); @@ -482,7 +482,7 @@ public: * not mean, that the resolved object does not exist, as it may be resolved * later. */ - bool resolve(const Rtti &type, const std::vector<std::string> &path, + bool resolve(const Rtti *type, const std::vector<std::string> &path, Handle<Node> owner, Logger &logger, ResolutionImposterCallback imposterCallback, ResolutionResultCallback resultCallback); @@ -505,7 +505,7 @@ public: * mean, that the resolved object does not exist, as it may be resolved * later. */ - bool resolve(const Rtti &type, const std::vector<std::string> &path, + bool resolve(const Rtti *type, const std::vector<std::string> &path, Handle<Node> owner, Logger &logger, ResolutionResultCallback resultCallback); diff --git a/src/core/resource/ResourceManager.cpp b/src/core/resource/ResourceManager.cpp index 56c9583..74fd5ad 100644 --- a/src/core/resource/ResourceManager.cpp +++ b/src/core/resource/ResourceManager.cpp @@ -215,9 +215,9 @@ NodeVector<Node> ResourceManager::parse( // Make sure the parsed nodes fulfill the "supportedTypes" constraint, // remove nodes that do not the result for (auto it = parsedNodes.begin(); it != parsedNodes.end();) { - const Rtti &type = (*it)->type(); - if (!type.isOneOf(supportedTypes)) { - logger.error(std::string("Node of internal type ") + type.name + + const Rtti *type = (*it)->type(); + if (!type->isOneOf(supportedTypes)) { + logger.error(std::string("Node of internal type ") + type->name + std::string(" not supported here"), **it); it = parsedNodes.erase(it); diff --git a/src/plugins/html/DemoOutput.cpp b/src/plugins/html/DemoOutput.cpp index 074e65e..d61e9b7 100644 --- a/src/plugins/html/DemoOutput.cpp +++ b/src/plugins/html/DemoOutput.cpp @@ -151,7 +151,7 @@ Rooted<xml::Element> DemoHTMLTransformer::transformSection( // Then we get all the children. for (auto &n : section->getField()) { - if (!n->isa(RttiTypes::StructuredEntity)) { + if (!n->isa(&RttiTypes::StructuredEntity)) { continue; } Handle<StructuredEntity> s = n.cast<StructuredEntity>(); @@ -266,7 +266,7 @@ Rooted<xml::Element> DemoHTMLTransformer::transformParagraph( // this is a handle for our current XML element for annotation handling. Rooted<xml::Element> current = p; for (auto &n : par->getField()) { - if (n->isa(RttiTypes::Anchor)) { + if (n->isa(&RttiTypes::Anchor)) { // check if this is a start Anchor. // here we assume, again, that the ids/names of anchors are unique. auto it = startMap.find(n->getName()); @@ -315,7 +315,7 @@ Rooted<xml::Element> DemoHTMLTransformer::transformParagraph( continue; } // if this is not an anchor, we can only handle text. - if (!n->isa(RttiTypes::StructuredEntity)) { + if (!n->isa(&RttiTypes::StructuredEntity)) { continue; } Handle<StructuredEntity> t = n.cast<StructuredEntity>(); diff --git a/src/plugins/xml/XmlParser.cpp b/src/plugins/xml/XmlParser.cpp index bd9b681..4f956d5 100644 --- a/src/plugins/xml/XmlParser.cpp +++ b/src/plugins/xml/XmlParser.cpp @@ -97,7 +97,7 @@ public: { // check if the parent in the structure tree was an explicit field // reference. - inField = parentNode->isa(RttiTypes::DocumentField); + inField = parentNode->isa(&RttiTypes::DocumentField); if (inField) { fieldName = parentNode->getName(); parentNode = scope().selectOrThrow( @@ -108,10 +108,10 @@ public: } // reference the parent entity explicitly. parent = nullptr; - if (parentNode->isa(RttiTypes::StructuredEntity)) { + if (parentNode->isa(&RttiTypes::StructuredEntity)) { parent = static_cast<DocumentEntity *>( parentNode.cast<StructuredEntity>().get()); - } else if (parentNode->isa(RttiTypes::AnnotationEntity)) { + } else if (parentNode->isa(&RttiTypes::AnnotationEntity)) { parent = static_cast<DocumentEntity *>( parentNode.cast<AnnotationEntity>().get()); } @@ -157,7 +157,7 @@ public: args.erase(it); } Rooted<StructuredEntity> entity; - if (parentNode->isa(RttiTypes::Document)) { + if (parentNode->isa(&RttiTypes::Document)) { entity = parentNode.cast<Document>()->createRootStructuredEntity( strct, args, name); } else { @@ -762,7 +762,7 @@ public: Logger &logger) { if (parent != nullptr) { auto res = parent.cast<Descriptor>()->resolve( - RttiTypes::FieldDescriptor, name); + &RttiTypes::FieldDescriptor, name); if (res.size() != 1) { logger.error( std::string("Could not find referenced field ") + name, @@ -840,7 +840,7 @@ public: // Fetch the last node and check whether an import is valid at this // position Rooted<Node> leaf = scope().getLeaf(); - if (leaf == nullptr || !leaf->isa(RttiTypes::RootNode)) { + if (leaf == nullptr || !leaf->isa(&RttiTypes::RootNode)) { logger().error( "Import not supported here, must be inside a document, domain " "or typesystem command.", diff --git a/test/core/common/ArgumentTest.cpp b/test/core/common/ArgumentTest.cpp index 43574c1..0a2dcfa 100644 --- a/test/core/common/ArgumentTest.cpp +++ b/test/core/common/ArgumentTest.cpp @@ -367,7 +367,7 @@ TEST(Argument, validateStringDefault) TEST(Argument, validateObject) { Manager mgr; - Argument a = Argument::Object("a", RttiTypes::TestManaged1); + Argument a = Argument::Object("a", &RttiTypes::TestManaged1); ASSERT_FALSE(a.hasDefault()); @@ -419,7 +419,7 @@ TEST(Argument, validateObject) TEST(Argument, validateObjectDefault) { Manager mgr; - Argument a = Argument::Object("a", RttiTypes::TestManaged1, nullptr); + Argument a = Argument::Object("a", &RttiTypes::TestManaged1, nullptr); ASSERT_TRUE(a.hasDefault()); ASSERT_TRUE(a.getDefaultValue().isObject()); @@ -578,7 +578,7 @@ TEST(Argument, validateArrayDefault) TEST(Argument, validateArrayInner) { - Argument a = Argument::Array("a", RttiTypes::String); + Argument a = Argument::Array("a", &RttiTypes::String); ASSERT_FALSE(a.hasDefault()); @@ -612,7 +612,7 @@ TEST(Argument, validateArrayInner) TEST(Argument, validateArrayInnerDefault) { Variant::arrayType arrDefault{1, "a", nullptr}; - Argument a = Argument::Array("a", RttiTypes::String, arrDefault); + Argument a = Argument::Array("a", &RttiTypes::String, arrDefault); ASSERT_TRUE(a.hasDefault()); ASSERT_TRUE(a.getDefaultValue().isArray()); @@ -698,7 +698,7 @@ TEST(Argument, validateMapDefault) TEST(Argument, validateMapInnerType) { - Argument a = Argument::Map("a", RttiTypes::String); + Argument a = Argument::Map("a", &RttiTypes::String); ASSERT_FALSE(a.hasDefault()); @@ -737,7 +737,7 @@ TEST(Argument, validateMapInnerType) TEST(Argument, validateMapInnerTypeDefault) { Variant::mapType mapDefault{{"key1", "1"}}; - Argument a = Argument::Map("a", RttiTypes::String, mapDefault); + Argument a = Argument::Map("a", &RttiTypes::String, mapDefault); ASSERT_TRUE(a.hasDefault()); ASSERT_TRUE(a.getDefaultValue().isMap()); diff --git a/test/core/common/PropertyTest.cpp b/test/core/common/PropertyTest.cpp index 0f3d74e..f57b4c0 100644 --- a/test/core/common/PropertyTest.cpp +++ b/test/core/common/PropertyTest.cpp @@ -62,7 +62,7 @@ TEST(Getter, construction) TEST(Getter, validation) { std::shared_ptr<PropertyType> type = - std::make_shared<PropertyType>(RttiTypes::Int); + std::make_shared<PropertyType>(&RttiTypes::Int); TestObject obj{123}; { @@ -111,7 +111,7 @@ TEST(Setter, construction) TEST(Setter, validation) { std::shared_ptr<PropertyType> type = - std::make_shared<PropertyType>(RttiTypes::Int); + std::make_shared<PropertyType>(&RttiTypes::Int); TestObject obj{123}; Setter<TestObject> setter{TestObject::setA}; @@ -164,7 +164,7 @@ TEST(Property, construction) } { - Property<TestObject> property{RttiTypes::Int, TestObject::getA, + Property<TestObject> property{&RttiTypes::Int, TestObject::getA, TestObject::setA}; ASSERT_FALSE(property.isReadonly()); diff --git a/test/core/common/RttiTest.cpp b/test/core/common/RttiTest.cpp index 019750a..7fcfd11 100644 --- a/test/core/common/RttiTest.cpp +++ b/test/core/common/RttiTest.cpp @@ -59,63 +59,63 @@ const Rtti Type7 = RttiBuilder<RttiTestClass7>{"Type7"}.parent(&Type6); TEST(Rtti, isa) { - ASSERT_TRUE(Type1.isa(Type1)); - ASSERT_FALSE(Type1.isa(Type2)); - ASSERT_FALSE(Type1.isa(Type3)); - ASSERT_FALSE(Type1.isa(Type4)); - - ASSERT_FALSE(Type2.isa(Type1)); - ASSERT_TRUE(Type2.isa(Type2)); - ASSERT_FALSE(Type2.isa(Type3)); - ASSERT_FALSE(Type2.isa(Type4)); - - ASSERT_TRUE(Type3.isa(Type1)); - ASSERT_FALSE(Type3.isa(Type2)); - ASSERT_TRUE(Type3.isa(Type3)); - ASSERT_FALSE(Type3.isa(Type4)); - - ASSERT_TRUE(Type4.isa(Type1)); - ASSERT_TRUE(Type4.isa(Type2)); - ASSERT_TRUE(Type4.isa(Type3)); - ASSERT_TRUE(Type4.isa(Type4)); + ASSERT_TRUE(Type1.isa(&Type1)); + ASSERT_FALSE(Type1.isa(&Type2)); + ASSERT_FALSE(Type1.isa(&Type3)); + ASSERT_FALSE(Type1.isa(&Type4)); + + ASSERT_FALSE(Type2.isa(&Type1)); + ASSERT_TRUE(Type2.isa(&Type2)); + ASSERT_FALSE(Type2.isa(&Type3)); + ASSERT_FALSE(Type2.isa(&Type4)); + + ASSERT_TRUE(Type3.isa(&Type1)); + ASSERT_FALSE(Type3.isa(&Type2)); + ASSERT_TRUE(Type3.isa(&Type3)); + ASSERT_FALSE(Type3.isa(&Type4)); + + ASSERT_TRUE(Type4.isa(&Type1)); + ASSERT_TRUE(Type4.isa(&Type2)); + ASSERT_TRUE(Type4.isa(&Type3)); + ASSERT_TRUE(Type4.isa(&Type4)); } TEST(Rtti, composedOf) { std::vector<const Rtti *> types{&Type1, &Type2, &Type3, &Type4}; for (auto t : types) { - ASSERT_FALSE(t->composedOf(Type1)); - ASSERT_FALSE(t->composedOf(Type2)); - ASSERT_FALSE(t->composedOf(Type3)); - ASSERT_FALSE(t->composedOf(Type4)); - ASSERT_FALSE(t->composedOf(Type5)); - ASSERT_FALSE(t->composedOf(Type6)); - ASSERT_FALSE(t->composedOf(Type7)); + ASSERT_FALSE(t->composedOf(&Type1)); + ASSERT_FALSE(t->composedOf(&Type2)); + ASSERT_FALSE(t->composedOf(&Type3)); + ASSERT_FALSE(t->composedOf(&Type4)); + ASSERT_FALSE(t->composedOf(&Type5)); + ASSERT_FALSE(t->composedOf(&Type6)); + ASSERT_FALSE(t->composedOf(&Type7)); } - ASSERT_TRUE(Type5.composedOf(Type1)); - ASSERT_FALSE(Type5.composedOf(Type2)); - ASSERT_FALSE(Type5.composedOf(Type3)); - ASSERT_FALSE(Type5.composedOf(Type4)); - ASSERT_FALSE(Type5.composedOf(Type5)); - ASSERT_TRUE(Type5.composedOf(Type6)); - ASSERT_TRUE(Type5.composedOf(Type7)); - - ASSERT_TRUE(Type6.composedOf(Type1)); - ASSERT_FALSE(Type6.composedOf(Type2)); - ASSERT_FALSE(Type6.composedOf(Type3)); - ASSERT_FALSE(Type6.composedOf(Type4)); - ASSERT_FALSE(Type6.composedOf(Type5)); - ASSERT_FALSE(Type6.composedOf(Type6)); - ASSERT_FALSE(Type6.composedOf(Type7)); - - ASSERT_TRUE(Type7.composedOf(Type1)); - ASSERT_FALSE(Type7.composedOf(Type2)); - ASSERT_FALSE(Type7.composedOf(Type3)); - ASSERT_FALSE(Type7.composedOf(Type4)); - ASSERT_FALSE(Type7.composedOf(Type5)); - ASSERT_FALSE(Type7.composedOf(Type6)); - ASSERT_FALSE(Type7.composedOf(Type7)); + ASSERT_TRUE(Type5.composedOf(&Type1)); + ASSERT_FALSE(Type5.composedOf(&Type2)); + ASSERT_FALSE(Type5.composedOf(&Type3)); + ASSERT_FALSE(Type5.composedOf(&Type4)); + ASSERT_FALSE(Type5.composedOf(&Type5)); + ASSERT_TRUE(Type5.composedOf(&Type6)); + ASSERT_TRUE(Type5.composedOf(&Type7)); + + ASSERT_TRUE(Type6.composedOf(&Type1)); + ASSERT_FALSE(Type6.composedOf(&Type2)); + ASSERT_FALSE(Type6.composedOf(&Type3)); + ASSERT_FALSE(Type6.composedOf(&Type4)); + ASSERT_FALSE(Type6.composedOf(&Type5)); + ASSERT_FALSE(Type6.composedOf(&Type6)); + ASSERT_FALSE(Type6.composedOf(&Type7)); + + ASSERT_TRUE(Type7.composedOf(&Type1)); + ASSERT_FALSE(Type7.composedOf(&Type2)); + ASSERT_FALSE(Type7.composedOf(&Type3)); + ASSERT_FALSE(Type7.composedOf(&Type4)); + ASSERT_FALSE(Type7.composedOf(&Type5)); + ASSERT_FALSE(Type7.composedOf(&Type6)); + ASSERT_FALSE(Type7.composedOf(&Type7)); } class RttiMethodTestClass1 { @@ -218,12 +218,12 @@ public: }; static const Rtti PType1 = RttiBuilder<RttiPropertyTestClass1>{ - "PType1"}.property("a", {RttiTypes::Int, RttiPropertyTestClass1::getA, + "PType1"}.property("a", {&RttiTypes::Int, RttiPropertyTestClass1::getA, RttiPropertyTestClass1::setA}); static const Rtti PType2 = RttiBuilder<RttiPropertyTestClass2>{"PType2"}.parent(&PType1).property( - "b", {RttiTypes::Int, RttiPropertyTestClass2::getB, + "b", {&RttiTypes::Int, RttiPropertyTestClass2::getB, RttiPropertyTestClass2::setB}); TEST(Rtti, properties) diff --git a/test/core/common/VariantConverterTest.cpp b/test/core/common/VariantConverterTest.cpp index ab18f14..9654a7b 100644 --- a/test/core/common/VariantConverterTest.cpp +++ b/test/core/common/VariantConverterTest.cpp @@ -249,7 +249,7 @@ TEST(VariantConverter, toString) } static void assertArrayConversion(Variant conv, Variant expected, - bool expectedSuccess, const Rtti &innerType, + bool expectedSuccess, const Rtti *innerType, VariantConverter::Mode mode, Logger &logger) { EXPECT_EQ(expectedSuccess, @@ -276,48 +276,48 @@ TEST(VariantConverter, toArray) Variant C = card; // in safe mode only array to array conversion should be possible. - assertArrayConversion(n, nullptr, false, RttiTypes::None, + assertArrayConversion(n, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(b, nullptr, false, RttiTypes::None, + assertArrayConversion(b, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(i, nullptr, false, RttiTypes::None, + assertArrayConversion(i, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(d, nullptr, false, RttiTypes::None, + assertArrayConversion(d, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(s, nullptr, false, RttiTypes::None, + assertArrayConversion(s, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(A, A, true, RttiTypes::None, + assertArrayConversion(A, A, true, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(M, nullptr, false, RttiTypes::None, + assertArrayConversion(M, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertArrayConversion(C, nullptr, false, RttiTypes::None, + assertArrayConversion(C, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); // in all mode more should be possible. - assertArrayConversion(n, Variant::arrayType{n}, true, RttiTypes::None, + assertArrayConversion(n, Variant::arrayType{n}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(b, Variant::arrayType{b}, true, RttiTypes::None, + assertArrayConversion(b, Variant::arrayType{b}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(i, Variant::arrayType{i}, true, RttiTypes::None, + assertArrayConversion(i, Variant::arrayType{i}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(d, Variant::arrayType{d}, true, RttiTypes::None, + assertArrayConversion(d, Variant::arrayType{d}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(s, Variant::arrayType{s}, true, RttiTypes::None, + assertArrayConversion(s, Variant::arrayType{s}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(A, A, true, RttiTypes::None, + assertArrayConversion(A, A, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(M, Variant::arrayType{M}, true, RttiTypes::None, + assertArrayConversion(M, Variant::arrayType{M}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertArrayConversion(C, Variant::arrayType{C}, true, RttiTypes::None, + assertArrayConversion(C, Variant::arrayType{C}, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); // as an example also check the inner type converion assertArrayConversion( A, Variant::arrayType{Variant(1), Variant(6), Variant(2), Variant(9)}, - true, RttiTypes::Int, VariantConverter::Mode::ALL, logger); + true, &RttiTypes::Int, VariantConverter::Mode::ALL, logger); } static void assertMapConversion(Variant conv, Variant expected, - bool expectedSuccess, const Rtti &innerType, + bool expectedSuccess, const Rtti *innerType, VariantConverter::Mode mode, Logger &logger) { EXPECT_EQ(expectedSuccess, @@ -344,39 +344,39 @@ TEST(VariantConverter, toMap) Variant C = card; // in safe mode only map to map conversion should be possible. - assertMapConversion(n, nullptr, false, RttiTypes::None, + assertMapConversion(n, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(b, nullptr, false, RttiTypes::None, + assertMapConversion(b, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(i, nullptr, false, RttiTypes::None, + assertMapConversion(i, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(d, nullptr, false, RttiTypes::None, + assertMapConversion(d, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(s, nullptr, false, RttiTypes::None, + assertMapConversion(s, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(A, nullptr, false, RttiTypes::None, + assertMapConversion(A, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(M, M, true, RttiTypes::None, + assertMapConversion(M, M, true, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); - assertMapConversion(C, nullptr, false, RttiTypes::None, + assertMapConversion(C, nullptr, false, &RttiTypes::None, VariantConverter::Mode::SAFE, logger); // in all mode that should be the same. - assertMapConversion(n, nullptr, false, RttiTypes::None, + assertMapConversion(n, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(b, nullptr, false, RttiTypes::None, + assertMapConversion(b, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(i, nullptr, false, RttiTypes::None, + assertMapConversion(i, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(d, nullptr, false, RttiTypes::None, + assertMapConversion(d, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(s, nullptr, false, RttiTypes::None, + assertMapConversion(s, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(A, nullptr, false, RttiTypes::None, + assertMapConversion(A, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(M, M, true, RttiTypes::None, + assertMapConversion(M, M, true, &RttiTypes::None, VariantConverter::Mode::ALL, logger); - assertMapConversion(C, nullptr, false, RttiTypes::None, + assertMapConversion(C, nullptr, false, &RttiTypes::None, VariantConverter::Mode::ALL, logger); // but we should be able to convert the inner type. @@ -384,14 +384,14 @@ TEST(VariantConverter, toMap) {"i", Variant(6)}, {"d", Variant(2)}, {"s", Variant(9)}}, - true, RttiTypes::Int, VariantConverter::Mode::ALL, + true, &RttiTypes::Int, VariantConverter::Mode::ALL, logger); // which should not work in SAFE mode. assertMapConversion(M, Variant::mapType{{"b", Variant(1)}, {"i", Variant(6)}, {"d", Variant(2)}, {"s", Variant(9)}}, - false, RttiTypes::Int, VariantConverter::Mode::SAFE, + false, &RttiTypes::Int, VariantConverter::Mode::SAFE, logger); } diff --git a/test/core/common/VariantTest.cpp b/test/core/common/VariantTest.cpp index 6381607..ee04034 100644 --- a/test/core/common/VariantTest.cpp +++ b/test/core/common/VariantTest.cpp @@ -40,7 +40,7 @@ TEST(Variant, nullValue) ASSERT_TRUE(v.isNull()); ASSERT_EQ(VariantType::NULLPTR, v.getType()); - ASSERT_EQ(&RttiTypes::Nullptr, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Nullptr, v.getRtti()); } TEST(Variant, booleanValue) @@ -57,7 +57,7 @@ TEST(Variant, booleanValue) ASSERT_TRUE(v.isBool()); ASSERT_TRUE(v.asBool()); ASSERT_EQ(VariantType::BOOL, v.getType()); - ASSERT_EQ(&RttiTypes::Bool, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Bool, v.getRtti()); v = nullptr; ASSERT_FALSE(v.isBool()); @@ -73,7 +73,7 @@ TEST(Variant, intValue) ASSERT_TRUE(v.isInt()); ASSERT_EQ(43, v.asInt()); ASSERT_EQ(VariantType::INT, v.getType()); - ASSERT_EQ(&RttiTypes::Int, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Int, v.getRtti()); v = false; ASSERT_FALSE(v.isInt()); @@ -92,7 +92,7 @@ TEST(Variant, doubleValue) ASSERT_TRUE(v.isDouble()); ASSERT_EQ(43.5, v.asDouble()); ASSERT_EQ(VariantType::DOUBLE, v.getType()); - ASSERT_EQ(&RttiTypes::Double, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Double, v.getRtti()); } TEST(Variant, stringValue) @@ -105,7 +105,7 @@ TEST(Variant, stringValue) ASSERT_TRUE(v.isString()); ASSERT_EQ("Goodbye Cruel World", v.asString()); ASSERT_EQ(VariantType::STRING, v.getType()); - ASSERT_EQ(&RttiTypes::String, &v.getRtti()); + ASSERT_EQ(&RttiTypes::String, v.getRtti()); v = 42; ASSERT_FALSE(v.isString()); @@ -134,7 +134,7 @@ TEST(Variant, cardinalityValue) ASSERT_TRUE(v.isCardinality()); ASSERT_EQ(VariantType::CARDINALITY, v.getType()); - ASSERT_EQ(&RttiTypes::Cardinality, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Cardinality, v.getRtti()); } @@ -147,7 +147,7 @@ TEST(Variant, arrayValue) ASSERT_TRUE(v.isArray()); ASSERT_EQ(VariantType::ARRAY, v.getType()); - ASSERT_EQ(&RttiTypes::Array, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Array, v.getRtti()); } TEST(Variant, mapValue) @@ -165,7 +165,7 @@ TEST(Variant, mapValue) ASSERT_TRUE(v.isMap()); ASSERT_EQ(VariantType::MAP, v.getType()); - ASSERT_EQ(&RttiTypes::Map, &v.getRtti()); + ASSERT_EQ(&RttiTypes::Map, v.getRtti()); } TEST(Variant, relationalOperators) diff --git a/test/core/managed/ManagedTest.cpp b/test/core/managed/ManagedTest.cpp index c2b19cf..653e7ef 100644 --- a/test/core/managed/ManagedTest.cpp +++ b/test/core/managed/ManagedTest.cpp @@ -93,14 +93,14 @@ TEST(Managed, type) Rooted<TypeTestManaged4> m4{new TypeTestManaged4(mgr)}; Rooted<TypeTestManaged5> m5{new TypeTestManaged5(mgr)}; - ASSERT_EQ(&Type1, &m1->type()); - ASSERT_EQ(&Type2, &m2->type()); - ASSERT_EQ(&Type3, &m3->type()); - ASSERT_EQ(&Type4, &m4->type()); - ASSERT_EQ(&RttiTypes::None, &m5->type()); - - ASSERT_EQ(&Type1, &typeOf<TypeTestManaged1>()); - ASSERT_EQ(&Type1, &typeOf(*m1)); + ASSERT_EQ(&Type1, m1->type()); + ASSERT_EQ(&Type2, m2->type()); + ASSERT_EQ(&Type3, m3->type()); + ASSERT_EQ(&Type4, m4->type()); + ASSERT_EQ(&RttiTypes::None, m5->type()); + + ASSERT_EQ(&Type1, typeOf<TypeTestManaged1>()); + ASSERT_EQ(&Type1, typeOf(*m1)); } class TestManagedEventOwner : public TestManaged { diff --git a/test/core/model/DomainTest.cpp b/test/core/model/DomainTest.cpp index 0c85d10..32ef7f0 100644 --- a/test/core/model/DomainTest.cpp +++ b/test/core/model/DomainTest.cpp @@ -28,7 +28,7 @@ namespace ousia { -void assert_path(const ResolutionResult &res, const Rtti &expected_type, +void assert_path(const ResolutionResult &res, const Rtti *expected_type, std::vector<std::string> expected_path) { // Check class/type @@ -50,41 +50,41 @@ TEST(Domain, testDomainResolving) std::vector<ResolutionResult> res; // There is one domain called "book" - res = domain->resolve(RttiTypes::Domain, "book"); + res = domain->resolve(&RttiTypes::Domain, "book"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], RttiTypes::Domain, {"book"}); + assert_path(res[0], &RttiTypes::Domain, {"book"}); // There is one domain called "book" - res = domain->resolve(RttiTypes::StructuredClass, "book"); + res = domain->resolve(&RttiTypes::StructuredClass, "book"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], RttiTypes::StructuredClass, {"book", "book"}); + assert_path(res[0], &RttiTypes::StructuredClass, {"book", "book"}); // If we explicitly ask for the "book, book" path, then only the // StructuredClass should be returned. - res = domain->resolve(RttiTypes::Domain, + res = domain->resolve(&RttiTypes::Domain, std::vector<std::string>{"book", "book"}); ASSERT_EQ(0U, res.size()); - res = domain->resolve(RttiTypes::StructuredClass, + res = domain->resolve(&RttiTypes::StructuredClass, std::vector<std::string>{"book", "book"}); ASSERT_EQ(1U, res.size()); // If we ask for "section" the result should be unique as well. - res = domain->resolve(RttiTypes::StructuredClass, "section"); + res = domain->resolve(&RttiTypes::StructuredClass, "section"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], RttiTypes::StructuredClass, {"book", "section"}); + assert_path(res[0], &RttiTypes::StructuredClass, {"book", "section"}); // If we ask for "paragraph" it is referenced two times in the Domain graph, // but should be returned only once. - res = domain->resolve(RttiTypes::StructuredClass, "paragraph"); + res = domain->resolve(&RttiTypes::StructuredClass, "paragraph"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], RttiTypes::StructuredClass, {"book", "paragraph"}); + assert_path(res[0], &RttiTypes::StructuredClass, {"book", "paragraph"}); } Rooted<StructuredClass> getClass(const std::string name, Handle<Domain> dom) { std::vector<ResolutionResult> res = - dom->resolve(RttiTypes::StructuredClass, name); + dom->resolve(&RttiTypes::StructuredClass, name); return res[0].node.cast<StructuredClass>(); } @@ -103,17 +103,17 @@ TEST(Descriptor, pathTo) // get the path in between. std::vector<Rooted<Node>> path = book->pathTo(section); ASSERT_EQ(1U, path.size()); - ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor)); + ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor)); // get the text node. Rooted<StructuredClass> text = getClass("text", domain); // get the path between book and text via paragraph. path = book->pathTo(text); ASSERT_EQ(3U, path.size()); - ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor)); - ASSERT_TRUE(path[1]->isa(RttiTypes::StructuredClass)); + ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor)); + ASSERT_TRUE(path[1]->isa(&RttiTypes::StructuredClass)); ASSERT_EQ("paragraph", path[1]->getName()); - ASSERT_TRUE(path[2]->isa(RttiTypes::FieldDescriptor)); + ASSERT_TRUE(path[2]->isa(&RttiTypes::FieldDescriptor)); // get the subsection node. Rooted<StructuredClass> subsection = getClass("subsection", domain); @@ -208,11 +208,11 @@ TEST(Descriptor, pathToAdvanced) // and now we should be able to find the shortest path as suggested std::vector<Rooted<Node>> path = start->pathTo(target); ASSERT_EQ(3U, path.size()); - ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor)); + ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor)); ASSERT_EQ("second", path[0]->getName()); - ASSERT_TRUE(path[1]->isa(RttiTypes::StructuredClass)); + ASSERT_TRUE(path[1]->isa(&RttiTypes::StructuredClass)); ASSERT_EQ("B", path[1]->getName()); - ASSERT_TRUE(path[2]->isa(RttiTypes::FieldDescriptor)); + ASSERT_TRUE(path[2]->isa(&RttiTypes::FieldDescriptor)); ASSERT_EQ("$default", path[2]->getName()); } diff --git a/test/core/model/NodeTest.cpp b/test/core/model/NodeTest.cpp index d9ca5bb..cdcd018 100644 --- a/test/core/model/NodeTest.cpp +++ b/test/core/model/NodeTest.cpp @@ -85,18 +85,18 @@ TEST(Node, resolveCompositaSimple) child1->addCompositum(new TestNode(mgr, "child11")); std::vector<ResolutionResult> res; - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"root", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); } @@ -111,18 +111,18 @@ TEST(Node, resolveCompositaDouble) child1->addCompositum(new TestNode(mgr, "child11")); std::vector<ResolutionResult> res; - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"root", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); } @@ -141,14 +141,14 @@ TEST(Node, resolveAmbigousComposita) child12->addCompositum(new TestNode(mgr, "child11")); std::vector<ResolutionResult> res; - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1", "child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); @@ -168,30 +168,30 @@ TEST(Node, resolveReferences) child12->addCompositum(new TestNode(mgr, "child11")); std::vector<ResolutionResult> res; - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"a", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"b", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child112 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1", "child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child1"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child1 == res[0].node || child1 == res[1].node); ASSERT_TRUE(child12 == res[0].node || child12 == res[1].node); @@ -212,31 +212,31 @@ TEST(Node, resolveReferencesAndComposita) Rooted<TestNode> child13 = root->addCompositum(new TestNode(mgr, "child1")); std::vector<ResolutionResult> res; - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"a", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"b", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child112 == res[0].node); - res = root->resolve(RttiTypes::TestNode, + res = root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1", "child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"}); ASSERT_EQ(2U, res.size()); ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node); ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node); // Resolving for "child1" should not descend into the referenced nodes res = - root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child1"}); + root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child13 == res[0].node); } diff --git a/test/core/model/TestAdvanced.hpp b/test/core/model/TestAdvanced.hpp index 5c709f0..915d973 100644 --- a/test/core/model/TestAdvanced.hpp +++ b/test/core/model/TestAdvanced.hpp @@ -32,7 +32,7 @@ static Rooted<StructuredClass> resolveDescriptor(Handle<Domain> domain, { // use the actual resolve method. std::vector<ResolutionResult> resolved = - domain->resolve(RttiTypes::StructuredClass, className); + domain->resolve(&RttiTypes::StructuredClass, className); // take the first valid result. for (auto &r : resolved) { return r.node.cast<StructuredClass>(); diff --git a/test/core/model/TestDocumentBuilder.hpp b/test/core/model/TestDocumentBuilder.hpp index 3d24839..fc76b07 100644 --- a/test/core/model/TestDocumentBuilder.hpp +++ b/test/core/model/TestDocumentBuilder.hpp @@ -45,7 +45,7 @@ static std::string getPathString(const Path &path) static Rooted<Descriptor> resolveDescriptor(Handle<Document> doc, Logger &logger, const Path &path, - const Rtti &type) + const Rtti *type) { // use the actual resolve method. std::vector<ResolutionResult> resolved = doc->resolve(type, path); @@ -96,7 +96,7 @@ Rooted<StructuredEntity> buildRootStructuredEntity( // If we can not find the correct descriptor, we can not build the entity // either. Rooted<Descriptor> descriptor = - resolveDescriptor(document, logger, path, RttiTypes::StructuredClass); + resolveDescriptor(document, logger, path, &RttiTypes::StructuredClass); if (descriptor == nullptr) { return {nullptr}; } @@ -146,11 +146,11 @@ Rooted<StructuredEntity> buildStructuredEntity( // If we can not find the correct descriptor, we can not build the entity // either. Rooted<Descriptor> descriptor = - resolveDescriptor(document, logger, path, RttiTypes::StructuredClass); + resolveDescriptor(document, logger, path, &RttiTypes::StructuredClass); if (descriptor == nullptr) { return {nullptr}; } - if (!descriptor->isa(RttiTypes::StructuredClass)) { + if (!descriptor->isa(&RttiTypes::StructuredClass)) { return {nullptr}; logger.error("The descriptor was not an AnnotationClass!"); } @@ -195,11 +195,11 @@ Rooted<AnnotationEntity> buildAnnotationEntity( // If we can not find the correct descriptor, we can not build the // entity either. Rooted<Descriptor> descriptor = - resolveDescriptor(document, logger, path, RttiTypes::AnnotationClass); + resolveDescriptor(document, logger, path, &RttiTypes::AnnotationClass); if (descriptor == nullptr) { return {nullptr}; } - if (!descriptor->isa(RttiTypes::AnnotationClass)) { + if (!descriptor->isa(&RttiTypes::AnnotationClass)) { return {nullptr}; logger.error("The descriptor was not an AnnotationClass!"); } diff --git a/test/core/model/TypesystemTest.cpp b/test/core/model/TypesystemTest.cpp index bf40356..9b5872c 100644 --- a/test/core/model/TypesystemTest.cpp +++ b/test/core/model/TypesystemTest.cpp @@ -37,20 +37,20 @@ TEST(StringType, rtti) Rooted<StringType> strType{new StringType(mgr, nullptr)}; ASSERT_TRUE(strType->isa(typeOf<Type>())); ASSERT_TRUE(strType->isa(typeOf<Node>())); - ASSERT_TRUE(strType->isa(RttiTypes::StringType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(strType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(strType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(strType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(strType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(strType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_TRUE(strType->isa(&RttiTypes::StringType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(strType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(StringType, creation) @@ -124,22 +124,22 @@ TEST(IntType, rtti) { Manager mgr; Rooted<IntType> intType{new IntType(mgr, nullptr)}; - ASSERT_TRUE(intType->isa(RttiTypes::IntType)); + ASSERT_TRUE(intType->isa(&RttiTypes::IntType)); ASSERT_TRUE(intType->isa(typeOf<Type>())); ASSERT_TRUE(intType->isa(typeOf<Node>())); - ASSERT_FALSE(intType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(intType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(intType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(intType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(intType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(intType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(intType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(IntType, creation) @@ -177,22 +177,22 @@ TEST(DoubleType, rtti) { Manager mgr; Rooted<DoubleType> doubleType{new DoubleType(mgr, nullptr)}; - ASSERT_TRUE(doubleType->isa(RttiTypes::DoubleType)); + ASSERT_TRUE(doubleType->isa(&RttiTypes::DoubleType)); ASSERT_TRUE(doubleType->isa(typeOf<Type>())); ASSERT_TRUE(doubleType->isa(typeOf<Node>())); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(doubleType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(doubleType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(DoubleType, creation) @@ -237,22 +237,22 @@ TEST(BoolType, rtti) { Manager mgr; Rooted<BoolType> boolType{new BoolType(mgr, nullptr)}; - ASSERT_TRUE(boolType->isa(RttiTypes::BoolType)); + ASSERT_TRUE(boolType->isa(&RttiTypes::BoolType)); ASSERT_TRUE(boolType->isa(typeOf<Type>())); ASSERT_TRUE(boolType->isa(typeOf<Node>())); - ASSERT_FALSE(boolType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(boolType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(boolType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(BoolType, creation) @@ -298,22 +298,22 @@ TEST(EnumType, rtti) Manager mgr; Rooted<EnumType> enumType{EnumType::createValidated( mgr, "enum", nullptr, {"a", "b", "c"}, logger)}; - ASSERT_TRUE(enumType->isa(RttiTypes::EnumType)); + ASSERT_TRUE(enumType->isa(&RttiTypes::EnumType)); ASSERT_TRUE(enumType->isa(typeOf<Type>())); ASSERT_TRUE(enumType->isa(typeOf<Node>())); - ASSERT_FALSE(enumType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(enumType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(enumType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(EnumType, creation) @@ -476,22 +476,22 @@ TEST(StructType, rtti) { Manager mgr; Rooted<StructType> structType = createStructType(mgr, logger); - ASSERT_TRUE(structType->isa(RttiTypes::StructType)); + ASSERT_TRUE(structType->isa(&RttiTypes::StructType)); ASSERT_TRUE(structType->isa(typeOf<Type>())); ASSERT_TRUE(structType->isa(typeOf<Node>())); - ASSERT_FALSE(structType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(structType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(structType->composedOf(RttiTypes::Constant)); - ASSERT_TRUE(structType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(structType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(structType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::Constant)); + ASSERT_TRUE(structType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(structType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(StructType, creation) @@ -789,22 +789,22 @@ TEST(ArrayType, rtti) Manager mgr; Rooted<StringType> stringType{new StringType(mgr, nullptr)}; Rooted<ArrayType> arrayType{new ArrayType(stringType)}; - ASSERT_TRUE(arrayType->isa(RttiTypes::ArrayType)); + ASSERT_TRUE(arrayType->isa(&RttiTypes::ArrayType)); ASSERT_TRUE(arrayType->isa(typeOf<Type>())); ASSERT_TRUE(arrayType->isa(typeOf<Node>())); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(arrayType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(arrayType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(ArrayType, creation) @@ -910,22 +910,22 @@ TEST(UnknownType, rtti) { Manager mgr; Rooted<UnknownType> unknownType{new UnknownType(mgr)}; - ASSERT_TRUE(unknownType->isa(RttiTypes::UnknownType)); + ASSERT_TRUE(unknownType->isa(&RttiTypes::UnknownType)); ASSERT_TRUE(unknownType->isa(typeOf<Type>())); ASSERT_TRUE(unknownType->isa(typeOf<Node>())); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::Type)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::StringType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::IntType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::DoubleType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::BoolType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::EnumType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::UnknownType)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::Constant)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(unknownType->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Type)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::StringType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::IntType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::DoubleType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::BoolType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::EnumType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::UnknownType)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Constant)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(unknownType->composedOf(&RttiTypes::SystemTypesystem)); } TEST(UnknownType, creation) @@ -956,19 +956,19 @@ TEST(Typesystem, rtti) { Manager mgr{1}; Rooted<Typesystem> typesystem{new Typesystem{mgr, "typesystem"}}; - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Type)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::StringType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::IntType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::DoubleType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::BoolType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::EnumType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::UnknownType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Constant)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Type)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StringType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::IntType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::DoubleType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::BoolType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::EnumType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::UnknownType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Constant)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::SystemTypesystem)); } /* Class SystemTypesystem */ @@ -977,18 +977,18 @@ TEST(SystemTypesystem, rtti) { Manager mgr{1}; Rooted<SystemTypesystem> typesystem{new SystemTypesystem{mgr}}; - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Type)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::StringType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::IntType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::DoubleType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::BoolType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::EnumType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::StructType)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::ArrayType)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::UnknownType)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Constant)); - ASSERT_TRUE(typesystem->composedOf(RttiTypes::Attribute)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::Typesystem)); - ASSERT_FALSE(typesystem->composedOf(RttiTypes::SystemTypesystem)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Type)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StringType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::IntType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::DoubleType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::BoolType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::EnumType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StructType)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::ArrayType)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::UnknownType)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Constant)); + ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Attribute)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::Typesystem)); + ASSERT_FALSE(typesystem->composedOf(&RttiTypes::SystemTypesystem)); } } diff --git a/test/plugins/xml/XmlParserTest.cpp b/test/plugins/xml/XmlParserTest.cpp index 4b5e1e4..af1ef56 100644 --- a/test/plugins/xml/XmlParserTest.cpp +++ b/test/plugins/xml/XmlParserTest.cpp @@ -120,7 +120,7 @@ static Rooted<StructuredClass> checkStructuredClass( Handle<StructuredClass> superclass = nullptr, bool transparent = false, bool root = false) { - auto res = domain->resolve(RttiTypes::StructuredClass, resolve); + auto res = domain->resolve(&RttiTypes::StructuredClass, resolve); if (res.size() != 1) { throw OusiaException("resolution error!"); } @@ -146,7 +146,7 @@ static Rooted<AnnotationClass> checkAnnotationClass( const std::string &resolve, const std::string &name, Handle<Domain> domain, Handle<StructType> attributesDescriptor = nullptr) { - auto res = domain->resolve(RttiTypes::AnnotationClass, resolve); + auto res = domain->resolve(&RttiTypes::AnnotationClass, resolve); if (res.size() != 1) { throw OusiaException("resolution error!"); } @@ -183,7 +183,7 @@ static void checkFieldDescriptor( FieldDescriptor::FieldType type = FieldDescriptor::FieldType::TREE, Handle<Type> primitiveType = nullptr, bool optional = false) { - auto res = desc->resolve(RttiTypes::FieldDescriptor, name); + auto res = desc->resolve(&RttiTypes::FieldDescriptor, name); ASSERT_EQ(1, res.size()); checkFieldDescriptor(res[0].node, name, parent, children, type, primitiveType, optional); |