Rethought task of the Project class: Only keeps track of the included documents -- does not have references to typesystems, domains etc. (this allows instances of these classes to be freed as soon as no document refers to them). Project should be a parent of Document. Project should resolve documents as composita (this allows to have between-document references).

1 files changed, 7 insertions, 31 deletions

diff --git a/src/core/model/Project.cpp b/src/core/model/Project.cpp
index fc08660..56a3af2 100644
--- a/src/core/model/Project.cpp
+++ b/src/core/model/Project.cpp
@@ -38,9 +38,7 @@ Project::Project(Manager &mgr)
 
 bool Project::doValidate(Logger &logger) const
 {
-	return continueValidation(documents, logger) &
-	       continueValidation(domains, logger) &
-	       continueValidation(typesystems, logger);
+	return continueValidation(documents, logger);
 }
 
 Rooted<SystemTypesystem> Project::getSystemTypesystem()
@@ -50,58 +48,36 @@ Rooted<SystemTypesystem> Project::getSystemTypesystem()
 
 Rooted<Typesystem> Project::createTypesystem(const std::string &name)
 {
-	Rooted<Typesystem> typesystem{
+	return Rooted<Typesystem>{
 	    new Typesystem{getManager(), systemTypesystem, name}};
-	addTypesystem(typesystem);
-	return typesystem;
-}
-
-void Project::addTypesystem(Handle<Typesystem> typesystem)
-{
-	invalidate();
-	typesystems.push_back(typesystem);
 }
 
 Rooted<Document> Project::createDocument(const std::string &name)
 {
-	Rooted<Document> document{new Document(getManager(), name)};
+	return Rooted<Document> document{new Document(getManager(), name)};
 	addDocument(document);
 	return document;
 }
 
-void Project::addDocument(Handle<Document> document)
-{
-	invalidate();
-	documents.push_back(document);
-}
-
 Rooted<Domain> Project::createDomain(const std::string &name)
 {
-	Rooted<Domain> domain{new Domain(getManager(), systemTypesystem, name)};
-	addDomain(domain);
-	return domain;
+	return Rooted<Domain>{new Domain(getManager(), systemTypesystem, name)};
 }
 
-void Project::addDomain(Handle<Domain> domain)
+void Project::addDocument(Handle<Document> document)
 {
 	invalidate();
-	domains.push_back(domain);
+	documents.push_back(document);
 }
 
 const NodeVector<Document> &Project::getDocuments() { return documents; }
-
-const NodeVector<Domain> &Project::getDomains() { return domains; }
-
-const NodeVector<Typesystem> &Project::getTypesystems() { return typesystems; }
 }
 
 namespace RttiTypes {
 const Rtti Project = RttiBuilder<model::Project>("Project")
                          .parent(&Node)
                          .composedOf(&Document)
-                         .composedOf(&Typesystem)
-                         .composedOf(&SystemTypesystem)
-                         .composedOf(&Domain);
+                         .composedOf(&SystemTypesystem);
 }
 }