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).

2 files changed, 14 insertions, 75 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);
 }
 }
 
diff --git a/src/core/model/Project.hpp b/src/core/model/Project.hpp
index 576bd60..4e2a43b 100644
--- a/src/core/model/Project.hpp
+++ b/src/core/model/Project.hpp
@@ -44,8 +44,9 @@ class Document;
 class Domain;
 
 /**
- * The Project class constitutes the top-level node in which documents, domains,
- * typesystems and other resources are embedded.
+ * The Project class constitutes the top-level node in which a collection of
+ * documents are stored. It also contains an instance of the SystemTypesystem
+ * and allows for simple creation of new Typesystem and Domain instances.
  */
 class Project : public Node {
 private:
@@ -60,16 +61,6 @@ private:
 	 */
 	NodeVector<Document> documents;
 
-	/**
-	 * List containing all loaded domains.
-	 */
-	NodeVector<Domain> domains;
-
-	/**
-	 * List containing all loaded typesystems.
-	 */
-	NodeVector<Typesystem> typesystems;
-
 protected:
 	/**
 	 * Validates the project and all parts it consists of.
@@ -103,13 +94,6 @@ public:
 	Rooted<Typesystem> createTypesystem(const std::string &name);
 
 	/**
-	 * Adds a single new typesystem to the project.
-	 *
-	 * @param typesystem is the typesystem that should be added to the project.
-	 */
-	void addTypesystem(Handle<Typesystem> typesystem);
-
-	/**
 	 * Returns a new document with the given name and adds it to the list of
 	 * documents.
 	 *
@@ -118,13 +102,6 @@ public:
 	Rooted<Document> createDocument(const std::string &name);
 
 	/**
-	 * Adds the given document to the list of documents in the project.
-	 *
-	 * @param document is the document that should be added to the project.
-	 */
-	void addDocument(Handle<Document> document);
-
-	/**
 	 * Returns a new domain with the given name and adds it to the list of
 	 * domains. Provides a reference of the system typesystem to the domain.
 	 *
@@ -133,32 +110,18 @@ public:
 	Rooted<Domain> createDomain(const std::string &name);
 
 	/**
-	 * Adds the given domain to the list of domains in the project.
+	 * Adds the given document to the list of documents in the project.
 	 *
-	 * @param domain is the document that should be added to the project.
+	 * @param document is the document that should be added to the project.
 	 */
-	void addDomain(Handle<Domain> domain);
+	void addDocument(Handle<Document> document);
 
 	/**
 	 * Returns all documents of this project.
 	 *
 	 * @return a reference pointing at the document list.
 	 */
-	const NodeVector<Document> &getDocuments();
-
-	/**
-	 * Returns all domains of this project.
-	 *
-	 * @return a reference pointing at the domain list.
-	 */
-	const NodeVector<Domain> &getDomains();
-
-	/**
-	 * Returns all typesystems of this project.
-	 *
-	 * @return a reference pointing at the typesystem list.
-	 */
-	const NodeVector<Typesystem> &getTypesystems();
+	const NodeVector<Document> &getDocuments() const;
 };
 }