From b6dbad5183f64368909d1e1e42ddcb323bc6e61c Mon Sep 17 00:00:00 2001
From: Andreas Stöckel <astoecke@techfak.uni-bielefeld.de>
Date: Tue, 6 Jan 2015 13:24:12 +0100
Subject: Using RttiBuilder to construct Rtti information

---
 src/core/model/Document.cpp   | 28 +++++++++++++++-------------
 src/core/model/Domain.cpp     | 20 ++++++++++++--------
 src/core/model/Typesystem.cpp | 39 +++++++++++++++++++++------------------
 3 files changed, 48 insertions(+), 39 deletions(-)

diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp
index b700ba4..f40e452 100644
--- a/src/core/model/Document.cpp
+++ b/src/core/model/Document.cpp
@@ -191,19 +191,21 @@ Rooted<DocumentPrimitive> DocumentPrimitive::buildEntity(
 }
 
 namespace RttiTypes {
-const Rtti<model::Document> Document{
-    "Document", {&Node}, {&AnnotationEntity, &StructuredEntity}};
-const Rtti<model::DocumentEntity> DocumentEntity{"DocumentEntity", {&Node}};
-const Rtti<model::AnnotationEntity> AnnotationEntity{
-    "AnnotationEntity", {&DocumentEntity}, {&StructuredEntity}};
-const Rtti<model::StructuredEntity> StructuredEntity{
-    "StructuredEntity",
-    {&DocumentEntity},
-    {&StructuredEntity, &Anchor, &DocumentPrimitive}};
-const Rtti<model::DocumentPrimitive> DocumentPrimitive{"DocumentPrimitive",
-                                                       {&StructuredEntity}};
-const Rtti<model::AnnotationEntity::Anchor> Anchor{"Anchor",
-                                                   {&StructuredEntity}};
+const Rtti<model::DocumentEntity> DocumentEntity =
+    RttiBuilder("DocumentEntity").parent(&Node);
+const Rtti<model::Document> Document =
+    RttiBuilder("Document").parent(&Node).composedOf(
+        {&AnnotationEntity, &StructuredEntity});
+const Rtti<model::AnnotationEntity> AnnotationEntity =
+    RttiBuilder("AnnotationEntity").parent(&DocumentEntity).composedOf(
+        &StructuredEntity);
+const Rtti<model::StructuredEntity> StructuredEntity =
+    RttiBuilder("StructuredEntity").parent(&DocumentEntity).composedOf(
+        {&StructuredEntity, &Anchor, &DocumentPrimitive});
+const Rtti<model::DocumentPrimitive> DocumentPrimitive =
+    RttiBuilder("DocumentPrimitive").parent(&StructuredEntity);
+const Rtti<model::AnnotationEntity::Anchor> Anchor =
+    RttiBuilder("Anchor").parent(&StructuredEntity);
 }
 }
 
diff --git a/src/core/model/Domain.cpp b/src/core/model/Domain.cpp
index f9e2a55..e2aaba4 100644
--- a/src/core/model/Domain.cpp
+++ b/src/core/model/Domain.cpp
@@ -82,14 +82,18 @@ void Domain::doResolve(std::vector<Rooted<Managed>> &res,
 /* Type registrations */
 
 namespace RttiTypes {
-const Rtti<model::FieldDescriptor> FieldDescriptor{"FieldDescriptor", {&Node}};
-const Rtti<model::Descriptor> Descriptor{"Descriptor", {&Node}};
-const Rtti<model::StructuredClass> StructuredClass{
-    "StructuredClass", {&Descriptor}, {&FieldDescriptor}};
-const Rtti<model::AnnotationClass> AnnotationClass{"AnnotationClass",
-                                                   {&Descriptor}};
-const Rtti<model::Domain> Domain{
-    "Domain", {&Node}, {&StructuredClass, &AnnotationClass}};
+const Rtti<model::FieldDescriptor> FieldDescriptor =
+    RttiBuilder("FieldDescriptor").parent(&Node);
+const Rtti<model::Descriptor> Descriptor =
+    RttiBuilder("Descriptor").parent(&Node);
+const Rtti<model::StructuredClass> StructuredClass =
+    RttiBuilder("StructuredClass").parent(&Descriptor).composedOf(
+        &FieldDescriptor);
+const Rtti<model::AnnotationClass> AnnotationClass =
+    RttiBuilder("AnnotationClass").parent(&Descriptor);
+const Rtti<model::Domain> Domain =
+    RttiBuilder("Domain").parent(&Node).composedOf(
+        {&StructuredClass, &AnnotationClass});
 }
 }
 
diff --git a/src/core/model/Typesystem.cpp b/src/core/model/Typesystem.cpp
index 2945635..a852294 100644
--- a/src/core/model/Typesystem.cpp
+++ b/src/core/model/Typesystem.cpp
@@ -438,24 +438,27 @@ SystemTypesystem::SystemTypesystem(Manager &mgr)
 /* RTTI type registrations */
 
 namespace RttiTypes {
-const Rtti<model::Type> Type{"Type", {&Node}};
-const Rtti<model::StringType> StringType{"StringType", {&Type}};
-const Rtti<model::IntType> IntType{"IntType", {&Type}};
-const Rtti<model::DoubleType> DoubleType{"DoubleType", {&Type}};
-const Rtti<model::BoolType> BoolType{"BoolType", {&Type}};
-const Rtti<model::EnumType> EnumType{"EnumType", {&Type}};
-const Rtti<model::StructType> StructType{"StructType", {&Type}, {&Attribute}};
-const Rtti<model::ArrayType> ArrayType{"ArrayType", {&Type}};
-const Rtti<model::UnknownType> UnknownType{"UnknownType", {&Type}};
-const Rtti<model::Constant> Constant{"Constant", {&Node}};
-const Rtti<model::Attribute> Attribute{"Attribute", {&Node}};
-const Rtti<model::Typesystem> Typesystem{
-    "Typesystem",
-    {&Node},
-    {&StringType, &IntType, &DoubleType, &BoolType, &EnumType, &StructType,
-     &Constant}};
-const Rtti<model::SystemTypesystem> SystemTypesystem{"SystemTypesystem",
-                                                     {&Typesystem}};
+const Rtti<model::Type> Type = RttiBuilder("Type").parent(&Node);
+const Rtti<model::StringType> StringType =
+    RttiBuilder("StringType").parent(&Type);
+const Rtti<model::IntType> IntType = RttiBuilder("IntType").parent(&Type);
+const Rtti<model::DoubleType> DoubleType =
+    RttiBuilder("DoubleType").parent(&Type);
+const Rtti<model::BoolType> BoolType = RttiBuilder("BoolType").parent(&Type);
+const Rtti<model::EnumType> EnumType = RttiBuilder("EnumType").parent(&Type);
+const Rtti<model::StructType> StructType =
+    RttiBuilder("StructType").parent(&Type).composedOf(&Attribute);
+const Rtti<model::ArrayType> ArrayType = RttiBuilder("ArrayType").parent(&Type);
+const Rtti<model::UnknownType> UnknownType =
+    RttiBuilder("UnknownType").parent(&Type);
+const Rtti<model::Constant> Constant = RttiBuilder("Constant").parent(&Node);
+const Rtti<model::Attribute> Attribute = RttiBuilder("Attribute").parent(&Node);
+const Rtti<model::Typesystem> Typesystem =
+    RttiBuilder("Typesystem").parent(&Node).composedOf(
+        {&StringType, &IntType, &DoubleType, &BoolType, &EnumType, &StructType,
+         &Constant});
+const Rtti<model::SystemTypesystem> SystemTypesystem =
+    RttiBuilder("SystemTypesystem").parent(&Typesystem);
 }
 }
 
-- 
cgit v1.2.3