Simplify resolution callback, move NullResolveCallback to ResolutionCallbacks.cpp

5 files changed, 30 insertions, 46 deletions

diff --git a/src/core/model/ResolutionCallbacks.cpp b/src/core/model/ResolutionCallbacks.cpp
index 8c920f1..88f0aa8 100644
--- a/src/core/model/ResolutionCallbacks.cpp
+++ b/src/core/model/ResolutionCallbacks.cpp
@@ -19,5 +19,8 @@
 #include "ResolutionCallbacks.hpp"
 
 namespace ousia {
-	// Do nothing here, just make sure the header compiles
+Rooted<Node> NullResolveCallback(const Rtti *, const std::vector<std::string> &)
+{
+	return nullptr;
+}
 }
diff --git a/src/core/model/ResolutionCallbacks.hpp b/src/core/model/ResolutionCallbacks.hpp
index 2d9465d..2ac78a6 100644
--- a/src/core/model/ResolutionCallbacks.hpp
+++ b/src/core/model/ResolutionCallbacks.hpp
@@ -57,20 +57,19 @@ using ResolutionResultCallback = std::function<
 /**
  * The ResolveCallback can be used to trigger the resolution of a certain node.
  *
- * @param async if true, the resolution may be deferred. In this case the
- * resultCallback may be called at any later point in the program.
  * @param type is the type of node that should be resolved.
  * @param path is the path for which a node should be resolved.
- * @param resultCallback is the callback function to which the result of
- * the resolution process is passed. This function is called once the
- * resolution was successful.
- * @return true if the resolution was immediately successful. This does not
- * mean, that the resolved object does not exist, as it may be resolved
- * later.
+ * @return a the resolved node or nullptr if the resolution was not successful.
  */
 using ResolveCallback = std::function<
-    bool(bool async, const Rtti *type, const std::vector<std::string> &path,
-         ResolutionResultCallback resultCallback)>;
+    Rooted<Node>(const Rtti *type, const std::vector<std::string> &path)>;
+
+/**
+ * Empty implementation of the ResolveCallback, always returns nullptr.
+ */
+Rooted<Node> NullResolveCallback(const Rtti *,
+                                 const std::vector<std::string> &);
+
 }
 
 #endif /* _OUSIA_RESOLUTION_CALLBACKS_HPP_ */
diff --git a/src/core/model/Typesystem.cpp b/src/core/model/Typesystem.cpp
index 48e8d90..86ee811 100644
--- a/src/core/model/Typesystem.cpp
+++ b/src/core/model/Typesystem.cpp
@@ -25,15 +25,6 @@
 
 namespace ousia {
 
-/* Static helper functions */
-
-static bool NullResolveCallback(bool, const Rtti *,
-                                const std::vector<std::string> &,
-                                ResolutionResultCallback)
-{
-	return false;
-}
-
 /* Class Type */
 
 bool Type::build(Variant &data, Logger &logger,
@@ -41,15 +32,13 @@ bool Type::build(Variant &data, Logger &logger,
 {
 	// If the given variant is marked as "magic", try to resolve the real value
 	if (data.isMagic()) {
-		Rooted<Constant> constant;
-		if (resolveCallback(
-		        false, &RttiTypes::Constant, Utils::split(data.asMagic(), '.'),
-		        [&constant](Handle<Node> resolved, Handle<Node> owner,
-		                    Logger &logger) mutable {
-			        // Copy the resolution result out of this function
-			        constant = resolved.cast<Constant>();
-			    })) {
-			// Check whether the inner type of the constant is correct
+		// Try to resolve a constant
+		Rooted<Constant> constant =
+		    resolveCallback(&RttiTypes::Constant,
+		                    Utils::split(data.asMagic(), '.')).cast<Constant>();
+
+		// Check whether the inner type of the constant is correct
+		if (constant != nullptr) {
 			Rooted<Type> constantType = constant->getType();
 			if (!constantType->checkIsa(this)) {
 				logger.error(
diff --git a/src/core/parser/ParserScope.cpp b/src/core/parser/ParserScope.cpp
index 5e4b37f..7a7cb74 100644
--- a/src/core/parser/ParserScope.cpp
+++ b/src/core/parser/ParserScope.cpp
@@ -409,20 +409,15 @@ bool ParserScope::resolveType(const std::string &name, Handle<Node> owner,
 	return resolveType(Utils::split(name, '.'), owner, logger, resultCallback);
 }
 
-bool ParserScope::resolveValue(Variant &data, Handle<Node> owner,
-                               Handle<Type> type, Logger &logger)
+bool ParserScope::resolveValue(Variant &data, Handle<Type> type, Logger &logger)
 {
-	return type->build(data, logger,
-	                   [&](bool async, const Rtti *rttiType,
-	                       const std::vector<std::string> &path,
-	                       ResolutionResultCallback resultCallback) mutable {
-		if (!async) {
-			Rooted<Node> resolved = ParserScopeBase::resolve(rttiType, path, logger);
-			resultCallback(resolved, owner, logger);
-			return resolved != nullptr;
-		}
-		return resolve(rttiType, path, type, logger, resultCallback);
-	});
+	// Run the build function
+	return type->build(
+	    data, logger,
+	    [&logger, this](const Rtti *rttiType,
+	                    const std::vector<std::string> &path) mutable {
+		    return ParserScopeBase::resolve(rttiType, path, logger);
+		});
 }
 
 bool ParserScope::resolveTypeWithValue(const std::vector<std::string> &path,
@@ -440,7 +435,7 @@ bool ParserScope::resolveTypeWithValue(const std::vector<std::string> &path,
 	    [=](Handle<Node> resolved, Handle<Node> owner, Logger &logger) mutable {
 		    if (resolved != nullptr) {
 			    Rooted<Type> type = resolved.cast<Type>();
-			    scope.resolveValue(*valuePtr, owner, type, logger);
+			    scope.resolveValue(*valuePtr, type, logger);
 		    }
 
 		    // Call the result callback with the type
diff --git a/src/core/parser/ParserScope.hpp b/src/core/parser/ParserScope.hpp
index eec4751..b4ce037 100644
--- a/src/core/parser/ParserScope.hpp
+++ b/src/core/parser/ParserScope.hpp
@@ -700,14 +700,12 @@ public:
 	 * @param data is a reference at a variant that may contain magic values
 	 * (even in inner structures). The data will be passed to the "build"
 	 * function of the given type.
-	 * @param owner is the node for which the resolution takes place.
 	 * @param type is the Typesystem type the data should be interpreted with.
 	 * @param logger is the logger instance into which resolution problems
 	 * should be logged.
 	 * @return true if the value was successfully built.
 	 */
-	bool resolveValue(Variant &data, Handle<Node> owner, Handle<Type> type,
-	                  Logger &logger);
+	bool resolveValue(Variant &data, Handle<Type> type, Logger &logger);
 
 	/**
 	 * Resolves a type and makes sure the corresponding value is of the correct