summaryrefslogtreecommitdiff
path: root/src/core/managed
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/managed')
-rw-r--r--src/core/managed/Managed.hpp25
-rw-r--r--src/core/managed/ManagedType.hpp119
-rw-r--r--src/core/managed/Rtti.cpp (renamed from src/core/managed/ManagedType.cpp)32
-rw-r--r--src/core/managed/Rtti.hpp183
4 files changed, 218 insertions, 141 deletions
diff --git a/src/core/managed/Managed.hpp b/src/core/managed/Managed.hpp
index 4818c3d..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 {
- return ManagedType::typeOf(typeid(*this));
+ const RttiBase &type() const
+ {
+ 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
- * class is
+ * @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); }
};
/**
@@ -512,7 +512,6 @@ public:
*/
Managed *getOwner() const { return owner; }
};
-
}
#endif /* _OUSIA_MANAGED_HPP_ */
diff --git a/src/core/managed/ManagedType.hpp b/src/core/managed/ManagedType.hpp
deleted file mode 100644
index f3ed5fd..0000000
--- a/src/core/managed/ManagedType.hpp
+++ /dev/null
@@ -1,119 +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 <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _OUSIA_MANAGED_TYPE_HPP_
-#define _OUSIA_MANAGED_TYPE_HPP_
-
-#include <typeinfo>
-#include <typeindex>
-#include <unordered_map>
-#include <unordered_set>
-
-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<std::type_index, ManagedType *>& table() {
- static std::unordered_map<std::type_index, ManagedType *> 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::unordered_set<ManagedType *> parents;
-
-public:
- /**
- * ManagedType of no particular type.
- */
- static const ManagedType None;
-
- /**
- * Returns the ManagedType for the given type_info structure.
- */
- static const ManagedType &typeOf(const std::type_info &nativeType);
-
- /**
- * 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,
- std::unordered_set<ManagedType *> 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;
-};
-}
-
-#endif /* _OUSIA_MANAGED_TYPE_HPP_ */
-
diff --git a/src/core/managed/ManagedType.cpp b/src/core/managed/Rtti.cpp
index ed4c7da..eade524 100644
--- a/src/core/managed/ManagedType.cpp
+++ b/src/core/managed/Rtti.cpp
@@ -16,27 +16,39 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "ManagedType.hpp"
+#include "Rtti.hpp"
namespace ousia {
-/* Instantiation of static variables */
+/* Class RttiStore */
-const ManagedType ManagedType::None;
+std::unordered_map<std::type_index, const RttiBase *> &RttiStore::table()
+{
+ static std::unordered_map<std::type_index, const RttiBase *> table;
+ return table;
+}
-/* Class ManagedType */
+void RttiStore::store(const std::type_info &native, const RttiBase *rtti)
+{
+ table().emplace(std::type_index{native}, rtti);
+}
-const ManagedType &ManagedType::typeOf(const std::type_info &nativeType)
+const RttiBase &RttiStore::lookup(const std::type_info &native)
{
- auto it = table().find(std::type_index{nativeType});
- if (it == table().end()) {
- return None;
+ const auto &tbl = table();
+ auto it = tbl.find(std::type_index{native});
+ if (it == tbl.end()) {
+ return RttiBase::None;
} else {
return *(it->second);
}
}
-bool ManagedType::isa(const ManagedType &other) const
+/* Class RttiBase */
+
+const RttiBase RttiBase::None;
+
+bool RttiBase::isa(const RttiBase &other) const
{
if (&other == this) {
return true;
@@ -48,5 +60,7 @@ bool ManagedType::isa(const ManagedType &other) const
}
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 <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @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 <typeinfo>
+#include <typeindex>
+#include <unordered_map>
+#include <vector>
+
+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<std::type_index, const RttiBase *> &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<const RttiBase *> 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<const RttiBase *> parents =
+ std::vector<const RttiBase *>{})
+ : 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 T>
+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<const RttiBase *> &parents =
+ std::vector<const RttiBase *>{})
+ : 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 <typename T>
+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 <typename T>
+inline const RttiBase &typeOf(const T &obj)
+{
+ return RttiStore::lookup(typeid(obj));
+}
+}
+
+#endif /* _OUSIA_MANAGED_RTTI_HPP_ */
+
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-02 07:05:26 +0000