From a7567d08e4d5869833069ec7211785af350aea88 Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Sat, 20 Dec 2014 15:51:00 +0100 Subject: Renamed ManagedType class to Rtti to make naming less confusing, implemented easier to use Rtti clas --- src/core/managed/Managed.hpp | 18 ++-- src/core/managed/ManagedType.cpp | 52 ----------- src/core/managed/ManagedType.hpp | 175 ------------------------------------- src/core/managed/Rtti.cpp | 66 ++++++++++++++ src/core/managed/Rtti.hpp | 183 +++++++++++++++++++++++++++++++++++++++ src/core/model/Typesystem.cpp | 14 +-- 6 files changed, 265 insertions(+), 243 deletions(-) delete mode 100644 src/core/managed/ManagedType.cpp delete mode 100644 src/core/managed/ManagedType.hpp create mode 100644 src/core/managed/Rtti.cpp create mode 100644 src/core/managed/Rtti.hpp (limited to 'src') diff --git a/src/core/managed/Managed.hpp b/src/core/managed/Managed.hpp index cc55ae0..8582702 100644 --- a/src/core/managed/Managed.hpp +++ b/src/core/managed/Managed.hpp @@ -19,7 +19,7 @@ #ifndef _OUSIA_MANAGED_HPP_ #define _OUSIA_MANAGED_HPP_ -#include "ManagedType.hpp" +#include "Rtti.hpp" #include "Manager.hpp" namespace ousia { @@ -108,25 +108,25 @@ public: bool deleteData(const std::string &key); /** - * Returns the ManagedType instance registered for instances of the type - * of this Managed instance. + * Returns the RttiBase instance registered for instances of the type of + * this Managed instance. * - * @return a reference to the registered ManagedType for this particular + * @return a reference to the registered RttiBase for this particular * Managed class. */ - const ManagedType &type() const + const RttiBase &type() const { - return ManagedType::typeOf(*this); + return typeOf(*this); } /** - * Returns true if this Managed instance is of the given ManagedType. + * Returns true if this Managed instance is of the given RttiBase. * - * @param true if the ManagedType registered for this particular Managed + * @param true if the RttiBase registered for this particular Managed * class is of the given type or one of the registered parent types is of * the given type. */ - bool isa(const ManagedType &t) const { return type().isa(t); } + bool isa(const RttiBase &t) const { return type().isa(t); } }; /** diff --git a/src/core/managed/ManagedType.cpp b/src/core/managed/ManagedType.cpp deleted file mode 100644 index 53e75a3..0000000 --- a/src/core/managed/ManagedType.cpp +++ /dev/null @@ -1,52 +0,0 @@ -/* - Ousía - Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#include "ManagedType.hpp" - -namespace ousia { - -/* Instantiation of static variables */ - -const ManagedType ManagedType::None; - -/* Class ManagedType */ - -const ManagedType &ManagedType::rttiLookup(const std::type_info &nativeType) -{ - auto it = table().find(std::type_index{nativeType}); - if (it == table().end()) { - return None; - } else { - return *(it->second); - } -} - -bool ManagedType::isa(const ManagedType &other) const -{ - if (&other == this) { - return true; - } - for (auto t : parents) { - if (t->isa(other)) { - return true; - } - } - return false; -} -} - diff --git a/src/core/managed/ManagedType.hpp b/src/core/managed/ManagedType.hpp deleted file mode 100644 index 0a0d445..0000000 --- a/src/core/managed/ManagedType.hpp +++ /dev/null @@ -1,175 +0,0 @@ -/* - Ousía - Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#ifndef _OUSIA_MANAGED_TYPE_HPP_ -#define _OUSIA_MANAGED_TYPE_HPP_ - -#include - -#include -#include -#include -#include - -namespace ousia { - -/** - * The ManagedType is used to register type information that can be retrieved - * using the "type" method of the Managed class. - */ -class ManagedType { -private: - /** - * Used internally to store all registered native types and their - * corresponding type information. - */ - static std::unordered_map &table() - { - static std::unordered_map table; - return table; - } - - /** - * Name of the type -- for messages and debug output. - */ - const std::string name; - - /** - * Set containing references to the parent types. - */ - const std::vector parents; - - /** - * Returns the ManagedType for the given type_info structure. - * - * @param nativeType is a pointer at the C++ RTTI information. - */ - static const ManagedType &rttiLookup(const std::type_info &nativeType); - -public: - /** - * ManagedType of no particular type. - */ - static const ManagedType None; - - /** - * Returns the ManagedType for the given native type. - * - * @tparam T is the C++ type for which the type information should be - * returned. - * @param obj is a dummy object for which the type information should be - * returned. - */ - template - static const ManagedType &typeOf(const T &obj) - { - return rttiLookup(typeid(obj)); - } - - /** - * Returns the ManagedType for the given native type. - * - * @tparam T is the C++ type for which the type information should be - * returned. - */ - template - static const ManagedType &typeOf() - { - return rttiLookup(typeid(T)); - } - - /** - * Default constructor. Creates a ManagedType instance with name "unknown" - * and no parents. - */ - ManagedType() : name("unknown") {} - - /** - * Creates a new ManagedType instance and registers it in the global type - * table. - * - * @param name is the name of the type. - * @param nativeType is the underlying C++ class the type should be attached - * to. - */ - ManagedType(std::string name, const std::type_info &nativeType) - : name(std::move(name)) - { - table().emplace(std::make_pair(std::type_index{nativeType}, this)); - } - - /** - * Creates a new ManagedType instance and registers it in the global type - * table. - * - * @param name is the name of the type. - * @param nativeType is the underlying C++ class the type should be attached - * to. - * @param parents is a list of parent types. - */ - ManagedType(std::string name, const std::type_info &nativeType, - const std::vector &parents) - : name(std::move(name)), parents(parents) - { - table().emplace(std::make_pair(std::type_index{nativeType}, this)); - } - - /** - * Returns the name of this type. - */ - std::string getName() const { return name; } - - /** - * Returns true if this ManagedType instance is the given type or has the - * given type as one of its parents. - * - * @param other is the other type for which the relation to this type - * should be checked. - */ - bool isa(const ManagedType &other) const; -}; - -/** - * Function that can be used to retrieve the RTTI information of a Managed - * object. - * - * @tparam T is the C++ type for which the type information should be returned. - */ -template -inline const ManagedType &typeOf() -{ - return ManagedType::typeOf(); -} - -/** - * Function that can be used to retrieve the RTTI information of a Managed - * object. - * - * @tparam T is the C++ type for which the type information should be returned. - * @param obj is a dummy object for which the type information should be - * returned. - */ -template -inline const ManagedType &typeOf(const T &obj) -{ - return ManagedType::typeOf(obj); -} -} - -#endif /* _OUSIA_MANAGED_TYPE_HPP_ */ - diff --git a/src/core/managed/Rtti.cpp b/src/core/managed/Rtti.cpp new file mode 100644 index 0000000..eade524 --- /dev/null +++ b/src/core/managed/Rtti.cpp @@ -0,0 +1,66 @@ +/* + Ousía + Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "Rtti.hpp" + +namespace ousia { + +/* Class RttiStore */ + +std::unordered_map &RttiStore::table() +{ + static std::unordered_map table; + return table; +} + +void RttiStore::store(const std::type_info &native, const RttiBase *rtti) +{ + table().emplace(std::type_index{native}, rtti); +} + +const RttiBase &RttiStore::lookup(const std::type_info &native) +{ + const auto &tbl = table(); + auto it = tbl.find(std::type_index{native}); + if (it == tbl.end()) { + return RttiBase::None; + } else { + return *(it->second); + } +} + +/* Class RttiBase */ + +const RttiBase RttiBase::None; + +bool RttiBase::isa(const RttiBase &other) const +{ + if (&other == this) { + return true; + } + for (auto t : parents) { + if (t->isa(other)) { + return true; + } + } + return false; +} + + +} + diff --git a/src/core/managed/Rtti.hpp b/src/core/managed/Rtti.hpp new file mode 100644 index 0000000..f53fd9b --- /dev/null +++ b/src/core/managed/Rtti.hpp @@ -0,0 +1,183 @@ +/* + Ousía + Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/** + * @file Rtti.hpp + * + * Classes used for storing runtime type information (RTTI). RTTI is used to + * lookup objects in the object graph of a certain type and to attach + * information that should be accessible to the script engine. + * + * @author Andreas Stöckel (astoecke@techfak.uni-bielefeld.de) + */ + +#ifndef _OUSIA_MANAGED_RTTI_HPP_ +#define _OUSIA_MANAGED_RTTI_HPP_ + +#include +#include +#include +#include + +namespace ousia { + +class RttiBase; + +/** + * Helper class used to globally store and access the runtime type information. + */ +class RttiStore { +private: + /** + * Function used internally to access the static map storing all registered + * native types and their corresponding type information. + */ + static std::unordered_map &table(); + +public: + /** + * Registers the given pointer to the RttiBase class in the RTTI table. Does + * not override information for already registered types. + * + * @param native is a reference at the native type information provided + * by the compiler. + * @param rtti is a pointer pointing at the type information that should be + * stored for this type. + */ + static void store(const std::type_info &native, const RttiBase *rtti); + + /** + * Looks up the type information stored for the given native type + * information. + */ + static const RttiBase &lookup(const std::type_info &native); +}; + +/** + * The Rtti class allows for attaching data to native types that can be accessed + * at runtime. This type information can e.g. be retrieved using the "type" + * method of the Managed class. This system is used for attaching human readable + * names, parent types and script engine functionality. Use the Rtti class for + * convenient registration of type information. + */ +class RttiBase { +private: + /** + * Set containing references to the parent types. + */ + const std::vector parents; + +public: + /** + * Rtti of no particular type. + */ + static const RttiBase None; + + /** + * Human readable name associated with the type. + */ + const std::string name; + + /** + * Default constructor. Creates a Rtti instance with name "unknown" + * and no parents. + */ + RttiBase() : name("unknown") {} + + /** + * Creates a new RttiBase instance and registers it in the global type + * table. Use the Rtti class for more convinient registration of type + * information. + * + * @param name is the name of the type. + * @param native is a reference at the native type information provided by + * the compiler. + * @param parents is a list of parent types. + */ + RttiBase(std::string name, const std::type_info &native, + std::vector parents = + std::vector{}) + : parents(std::move(parents)), name(std::move(name)) + { + RttiStore::store(native, this); + } + + /** + * Returns true if this Rtti instance is the given type or has the + * given type as one of its parents. + * + * @param other is the other type for which the relation to this type + * should be checked. + */ + bool isa(const RttiBase &other) const; +}; + +/** + * The Rtti class allows for attaching data to native types that can be accessed + * at runtime. This type information can e.g. be retrieved using the "type" + * method of the Managed class. This system is used for attaching human + * readable names, parent types and script engine functionality. + * + * @tparam T is the class for which the type information should be registered. + */ +template +class Rtti : public RttiBase { +public: + /** + * Creates a new RttiBase instance and registers it in the global type + * table. + * + * @param name is the name of the type. + * @param parents is a list of parent types. + */ + Rtti(std::string name, const std::vector &parents = + std::vector{}) + : RttiBase(name, typeid(T), parents) + { + } +}; + +/** + * Function that can be used to retrieve the RTTI information of a Managed + * object. + * + * @tparam T is the C++ type for which the type information should be returned. + */ +template +inline const RttiBase &typeOf() +{ + return RttiStore::lookup(typeid(T)); +} + +/** + * Function that can be used to retrieve the RTTI information of a Managed + * object. + * + * @tparam T is the C++ type for which the type information should be returned. + * @param obj is a dummy object for which the type information should be + * returned. + */ +template +inline const RttiBase &typeOf(const T &obj) +{ + return RttiStore::lookup(typeid(obj)); +} +} + +#endif /* _OUSIA_MANAGED_RTTI_HPP_ */ + diff --git a/src/core/model/Typesystem.cpp b/src/core/model/Typesystem.cpp index 3fc8465..724bf0e 100644 --- a/src/core/model/Typesystem.cpp +++ b/src/core/model/Typesystem.cpp @@ -76,13 +76,13 @@ EnumType EnumType::createValidated(Manager &mgr, std::string name, /* RTTI type registrations */ -const ManagedType Type_T("Type", typeid(Type)); -const ManagedType StringType_T("StringType", typeid(StringType), {&Type_T}); -const ManagedType IntType_T("IntType", typeid(IntType), {&Type_T}); -const ManagedType DoubleType_T("DoubleType", typeid(DoubleType), {&Type_T}); -const ManagedType BoolType_T("BoolType", typeid(BoolType), {&Type_T}); -const ManagedType EnumType_T("EnumType", typeid(EnumType), {&Type_T}); -const ManagedType StructType_T("StructType", typeid(EnumType), {&Type_T}); +const Rtti Type_T("Type"); +const Rtti StringType_T("StringType", {&Type_T}); +const Rtti IntType_T("IntType", {&Type_T}); +const Rtti DoubleType_T("DoubleType", {&Type_T}); +const Rtti BoolType_T("BoolType", {&Type_T}); +const Rtti EnumType_T("EnumType", {&Type_T}); +const Rtti StructType_T("StructType", {&Type_T}); } } -- cgit v1.2.3