1 files changed, 27 insertions, 54 deletions

diff --git a/src/core/model/Domain.cpp b/src/core/model/Domain.cpp
index 49a3200..f03bd7a 100644
--- a/src/core/model/Domain.cpp
+++ b/src/core/model/Domain.cpp
@@ -23,73 +23,46 @@
 namespace ousia {
 namespace model {
 
-void FieldDescriptor::doResolve(std::vector<Rooted<Managed>> &res,
-                                const std::vector<std::string> &path,
-                                Filter filter, void *filterData, unsigned idx,
-                                VisitorSet &visited)
-{
-	// We call resolve for the children, but give them the field name as
-	// alias.
-	for (auto &c : children) {
-		c->resolve(res, path, filter, filterData, idx, visited, &getNameRef());
-	}
-}
+/* Class FieldDescriptor */
 
-// TODO: better alias?
-static std::string DESCRIPTOR_ATTRIBUTES_ALIAS{"attributes"};
+/* Class Descriptor */
 
-void Descriptor::doResolve(std::vector<Rooted<Managed>> &res,
-                           const std::vector<std::string> &path, Filter filter,
-                           void *filterData, unsigned idx, VisitorSet &visited)
+void Descriptor::continueResolve(ResolutionState &state)
 {
-	// TODO: This could be a problem, because the name of the field might be
-	// needed in the path.
-	for (auto &fd : fieldDescriptors) {
-		fd->resolve(res, path, filter, filterData, idx, visited, nullptr);
-	}
-	// TODO: This throws a SEGFAULT for some reason.
-	//	attributesDescriptor->resolve(res, path, filter, filterData, idx,
-	// visited,
-	//	                              &DESCRIPTOR_ATTRIBUTES_ALIAS);
+	const NodeVector<Attribute> &attributes =
+	    attributesDescriptor->getAttributes();
+	continueResolveComposita(attributes, attributes.getIndex(), state);
+	continueResolveComposita(fieldDescriptors, fieldDescriptors.getIndex(),
+	                         state);
 }
 
-//void StructuredClass::doResolve(std::vector<Rooted<Managed>> &res,
-//                                const std::vector<std::string> &path,
-//                                Filter filter, void *filterData, unsigned idx,
-//                                VisitorSet &visited)
-//{
-//	Descriptor::doResolve(res, path, filter, filterData, idx, visited);
-//	if (!isa.isNull()) {
-//		isa->doResolve(res, path, filter, filterData, idx, visited);
-//	}
-//}
+/* Class Domain */
 
-void Domain::doResolve(std::vector<Rooted<Managed>> &res,
-                       const std::vector<std::string> &path, Filter filter,
-                       void *filterData, unsigned idx, VisitorSet &visited)
+void Domain::continueResolve(ResolutionState &state)
 {
-	for (auto &s : structureClasses) {
-		s->resolve(res, path, filter, filterData, idx, visited, nullptr);
-	}
-	for (auto &a : annotationClasses) {
-		a->resolve(res, path, filter, filterData, idx, visited, nullptr);
-	}
-	for (auto &t : typesystems) {
-		t->resolve(res, path, filter, filterData, idx, visited, nullptr);
+	if (!continueResolveComposita(structureClasses, structureClasses.getIndex(),
+	                              state) |
+	    continueResolveComposita(annotationClasses,
+	                             annotationClasses.getIndex(), state)) {
+		continueResolveReferences(typesystems, state);
 	}
 }
 }
 /* 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});
 }
 }