4 files changed, 14 insertions, 151 deletions

diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp
index 9ea2d6e..1f2fb37 100644
--- a/src/core/model/Document.hpp
+++ b/src/core/model/Document.hpp
@@ -744,17 +744,6 @@ public:
 	}
 
 	/**
-	 * This sets up an empty document.
-	 *
-	 * @param mgr  is the Manager instance.
-	 * @param name is a name for this Document.
-	 */
-	static Rooted<Document> createEmptyDocument(Manager &mgr, std::string name)
-	{
-		return Rooted<Document>{new Document(mgr, std::move(name))};
-	}
-
-	/**
 	 * Sets the root StructuredEntity of this Document. This also sets the
 	 * parent of the given StructuredEntity if it is not set to this Document
 	 * already.
diff --git a/src/core/model/Node.hpp b/src/core/model/Node.hpp
index 6fc7dba..60d22e0 100644
--- a/src/core/model/Node.hpp
+++ b/src/core/model/Node.hpp
@@ -410,6 +410,7 @@ public:
 	 * Initializes the node with empty name and parent.
 	 *
 	 * @param mgr is a reference to the Manager instace the node belongs to.
+	 * @param parent is a handle pointing at the parent node.
 	 */
 	Node(Manager &mgr, Handle<Node> parent = nullptr)
 	    : Managed(mgr),
@@ -424,6 +425,8 @@ public:
 	 * @param mgr is a reference to the Manager instace the node belongs to.
 	 * @param name is the name of the Node.
 	 * @param parent is a handle pointing at the parent node.
+	 * @param location is the location in the source code at which this node
+	 * was defined.
 	 */
 	Node(Manager &mgr, std::string name, Handle<Node> parent = nullptr)
 	    : Managed(mgr),
@@ -540,7 +543,10 @@ public:
 	 * @param location describes the exact position of the Node in a source
 	 * file.
 	 */
-	void setLocation(const SourceLocation &location) {this->location = location;}
+	void setLocation(const SourceLocation &location)
+	{
+		this->location = location;
+	}
 };
 
 /**
diff --git a/src/core/model/Project.cpp b/src/core/model/Project.cpp
index 2833b37..b355969 100644
--- a/src/core/model/Project.cpp
+++ b/src/core/model/Project.cpp
@@ -17,8 +17,6 @@
 */
 
 #include <core/common/RttiBuilder.hpp>
-#include <core/parser/ParserScope.hpp>
-#include <core/parser/ParserContext.hpp>
 
 #include "Domain.hpp"
 #include "Document.hpp"
@@ -27,52 +25,22 @@
 
 namespace ousia {
 
-Project::Project(Manager &mgr, Registry &registry)
+Project::Project(Manager &mgr)
     : Node(mgr),
-      registry(registry),
       systemTypesystem(acquire(new SystemTypesystem(mgr))),
       documents(this)
 {
 }
 
-Rooted<Node> Project::parse(const std::string &path, const std::string mimetype,
-                            const std::string rel,
-                            const RttiSet &supportedTypes, Logger &logger)
-{
-	ParserScope scope;
-	ParserContext context(this, scope, logger);
-	return resourceManager.link(registry, context, path, mimetype, rel,
-	                            supportedTypes);
-}
-
-Rooted<Node> Project::link(ParserContext &ctx, const std::string &path,
-                           const std::string mimetype, const std::string rel,
-                           const RttiSet &supportedTypes)
-{
-	return resourceManager.link(registry, ctx, path, mimetype, rel,
-	                            supportedTypes);
-}
-
-Rooted<Node> Project::include(ParserContext &ctx, const std::string &path,
-                              const std::string mimetype, const std::string rel,
-                              const RttiSet &supportedTypes)
-{
-	return resourceManager.include(registry, ctx, path, mimetype, rel,
-	                               supportedTypes);
-}
-
-SourceContextCallback Project::getSourceContextCallback()
-{
-	return [&](const SourceLocation &location) {
-		return resourceManager.readContext(location);
-	};
-}
-
 bool Project::doValidate(Logger &logger) const
 {
 	return continueValidation(documents, logger);
 }
 
+void Project::doResolve(ResolutionState &state){
+	continueResolveComposita(documents, documents.getIndex(), state);
+}
+
 Rooted<SystemTypesystem> Project::getSystemTypesystem()
 {
 	return systemTypesystem;
diff --git a/src/core/model/Project.hpp b/src/core/model/Project.hpp
index 1c33dc8..9b81058 100644
--- a/src/core/model/Project.hpp
+++ b/src/core/model/Project.hpp
@@ -28,8 +28,6 @@
 #ifndef _OUSIA_PROJECT_HPP_
 #define _OUSIA_PROJECT_HPP_
 
-#include <core/resource/ResourceManager.hpp>
-
 #include "Node.hpp"
 
 namespace ousia {
@@ -38,7 +36,6 @@ namespace ousia {
 class Logger;
 class Rtti;
 class Registry;
-class ParserContext;
 class SystemTypesystem;
 class Typesystem;
 class Document;
@@ -52,11 +49,6 @@ class Domain;
 class Project : public Node {
 private:
 	/**
-	 * Reference at the internally used Registry instance.
-	 */
-	Registry &registry;
-
-	/**
 	 * Private instance of the system typesystem which is distributed as a
 	 * reference to all child typesystems.
 	 */
@@ -67,109 +59,17 @@ private:
 	 */
 	NodeVector<Document> documents;
 
-	/**
-	 * ResourceManager used to manage all resources used by the project.
-	 */
-	ResourceManager resourceManager;
-
 protected:
-	/**
-	 * Validates the project and all parts it consists of.
-	 *
-	 * @param logger is the logger instance to which errors will be logged.
-	 */
 	bool doValidate(Logger &loger) const override;
+	void doResolve(ResolutionState &state) override;
 
 public:
 	/**
 	 * Constructor of the Project class.
 	 *
 	 * @param mgr is the manager instance used for managing this Node.
-	 * @param registry is the registry instance that should be used for locating
-	 * files and finding parsers for these files.
-	 */
-	Project(Manager &mgr, Registry &registry);
-
-	/**
-	 * Parses a file with the given Logger in an empty ParserScope. This
-	 * function is meant to be called by the top-level (e.g. a main function)
-	 * and not by other parsers. These should use the link and include methods
-	 * instead.
-	 *
-	 * @param path is the path of the file that should be parsed.
-	 * @param mimetype is the mimetype of the resource that should be parsed
-	 * (may be empty, in which case the mimetype is deduced from the file
-	 * extension).
-	 * @param rel is a "relation string" supplied by the user which specifies
-	 * the relationship of the specified resource. May be empty, in which case
-	 * the relation is deduced from the supported types and the types of the
-	 * parser for the given mimetype.
-	 * @param supportedTypes contains the types of the returned Node the caller
-	 * can deal with. Note that only the types the parser claims to return are
-	 * checked, not the actual result.
-	 * @param logger is the logger that should be used
-	 * @return the parsed node or nullptr if something goes wrong.
-	 */
-	Rooted<Node> parse(const std::string &path, const std::string mimetype,
-	                   const std::string rel, const RttiSet &supportedTypes,
-	                   Logger &logger);
-
-	/**
-	 * Parses a file with ParserContext and an empty ParserScope. The parsed
-	 * object graph of files that are parsed using the "link" function is
-	 * cached (in contrast to the "include" function).
-	 *
-	 * @param ctx is the ParserContext that should be passed to the underlying
-	 * parser. The scope in the ParserContext will be exchanged.
-	 * @param path is the path of the file that should be parsed.
-	 * @param mimetype is the mimetype of the resource that should be parsed
-	 * (may be empty, in which case the mimetype is deduced from the file
-	 * extension).
-	 * @param rel is a "relation string" supplied by the user which specifies
-	 * the relationship of the specified resource. May be empty, in which case
-	 * the relation is deduced from the supported types and the types of the
-	 * parser for the given mimetype.
-	 * @param supportedTypes contains the types of the returned Node the caller
-	 * can deal with. Note that only the types the parser claims to return are
-	 * checked, not the actual result.
-	 * @return the parsed node or nullptr if something goes wrong.
-	 */
-	Rooted<Node> link(ParserContext &ctx, const std::string &path,
-	                  const std::string mimetype, const std::string rel,
-	                  const RttiSet &supportedTypes);
-
-	/**
-	 * Parses a file with ParserContext and the current ParserScope. In contrast
-	 * to the "link" function, include() does not cache the parsed node (as it
-	 * depends on the current ParserScope).
-	 *
-	 * @param ctx is the ParserContext that should be passed to the underlying
-	 * parser. The scope in the ParserContext will be exchanged.
-	 * @param path is the path of the file that should be parsed.
-	 * @param mimetype is the mimetype of the resource that should be parsed
-	 * (may be empty, in which case the mimetype is deduced from the file
-	 * extension).
-	 * @param rel is a "relation string" supplied by the user which specifies
-	 * the relationship of the specified resource. May be empty, in which case
-	 * the relation is deduced from the supported types and the types of the
-	 * parser for the given mimetype.
-	 * @param supportedTypes contains the types of the returned Node the caller
-	 * can deal with. Note that only the types the parser claims to return are
-	 * checked, not the actual result.
-	 * @return the parsed node or nullptr if something goes wrong.
-	 */
-	Rooted<Node> include(ParserContext &ctx, const std::string &path,
-	                     const std::string mimetype, const std::string rel,
-	                     const RttiSet &supportedTypes);
-
-	/**
-	 * Returns a SourceContextCallback that can be passed to a logger instance.
-	 * Remeber to reset the SourceContextCallback after the Project instance has
-	 * been freed.
-	 *
-	 * @return a SourceContextCallback that is coupled to this Project instance.
 	 */
-	SourceContextCallback getSourceContextCallback();
+	Project(Manager &mgr);
 
 	/**
 	 * Returns a reference to the internal system typesystem.