added parse, link and include functions to Project

2 files changed, 100 insertions, 0 deletions

diff --git a/src/core/model/Project.cpp b/src/core/model/Project.cpp
index a298ffc..1452de2 100644
--- a/src/core/model/Project.cpp
+++ b/src/core/model/Project.cpp
@@ -17,6 +17,8 @@
 */
 
 #include <core/common/RttiBuilder.hpp>
+#include <core/parser/ParserScope.hpp>
+#include <core/parser/ParserContext.hpp>
 
 #include "Domain.hpp"
 #include "Document.hpp"
@@ -33,6 +35,32 @@ Project::Project(Manager &mgr, Registry &registry)
 {
 }
 
+Rooted<Node> Project::parse(const std::string &path, const std::string mimetype,
+                            const std::string rel, 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,
+                           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,
+                              RttiSet &supportedTypes)
+{
+	return resourceManager.include(registry, ctx, path, mimetype, rel,
+	                               supportedTypes);
+}
+
 bool Project::doValidate(Logger &logger) const
 {
 	return continueValidation(documents, logger);
diff --git a/src/core/model/Project.hpp b/src/core/model/Project.hpp
index 2c50f49..4743454 100644
--- a/src/core/model/Project.hpp
+++ b/src/core/model/Project.hpp
@@ -91,6 +91,78 @@ public:
 	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, 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,
+	                  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,
+	                     RttiSet &supportedTypes);
+
+	/**
 	 * Returns a reference to the internal system typesystem.
 	 *
 	 * @return a reference to the system typesystem.