1 files changed, 121 insertions, 26 deletions
diff --git a/src/core/common/Function.hpp b/src/core/common/Function.hpp
index 79ee6b9..0e8af12 100644
--- a/src/core/common/Function.hpp
+++ b/src/core/common/Function.hpp
@@ -30,6 +30,7 @@
 
 #include <cassert>
 
+#include "Argument.hpp"
 #include "Variant.hpp"
 
 namespace ousia {
@@ -38,17 +39,18 @@ namespace ousia {
  * The Function interface defines all the methods needed to represent a
  * generic function. Function objects can be called using the "call" function in
  * which an array of Variant is supplied to the function and a Variant is
- * returned to the caller.
+ * returned to the caller. The actual function that is being represented by an
+ * instance of the Function class may either be a C++ function or a function
+ * residing in some script.
  */
 class Function {
 protected:
+	/**
+	 * Protecte default constructor -- prevents the Function class from being
+	 * created. Use one of the child classes instead.
+	 */
 	Function(){};
 
-public:
-	Function(const Function &) = delete;
-	Function(Function &&) = delete;
-	virtual ~Function(){};
-
 	/**
 	 * Abstract function which is meant to call the underlying function (be it
 	 * a host or a script function) with the given arguments.
@@ -57,8 +59,50 @@ public:
 	 * the function.
 	 * @return a Variant containing the return value.
 	 */
-	virtual Variant call(const Variant::arrayType &args = Variant::arrayType{},
-	                     void *thisRef = nullptr) const = 0;
+	virtual Variant doCall(Variant::arrayType &args, void *thisRef) const = 0;
+
+public:
+	// No copy constructor
+	Function(const Function &) = delete;
+
+	// No move constructor
+	Function(Function &&) = delete;
+
+	/**
+	 * Virtual destructor of the Function class.
+	 */
+	virtual ~Function(){};
+
+	/**
+	 * Calls the function.
+	 *
+	 * @param args is an array of variants that should be passed to the
+	 * function. Note that the arguments might be modified, e.g. by a validation
+	 * process or the called function itself.
+	 * @param thisRef is a user-defined reference which may be pointing at the
+	 * object the function should be working on.
+	 * @return a Variant containing the result of the function call.
+	 */
+	Variant call(Variant::arrayType &args, void *thisRef = nullptr) const
+	{
+		return doCall(args, thisRef);
+	}
+
+	/**
+	 * Calls the function.
+	 *
+	 * @param args is an array of variants that should be passed to the
+	 * function.
+	 * @param thisRef is a user-defined reference which may be pointing at the
+	 * object the function should be working on.
+	 * @return a Variant containing the result of the function call.
+	 */
+	Variant call(const Variant::arrayType &args = Variant::arrayType{},
+	             void *thisRef = nullptr) const
+	{
+		Variant::arrayType argsCopy = args;
+		return doCall(argsCopy, thisRef);
+	}
 };
 
 /**
@@ -66,16 +110,55 @@ public:
  * for instances of the Function class.
  */
 class FunctionStub : public Function {
+protected:
+	Variant doCall(Variant::arrayType &, void *) const override
+	{
+		return nullptr;
+	}
+
 public:
 	/**
 	 * Constructor of the FunctionStub class.
 	 */
 	FunctionStub() {}
+};
 
-	Variant call(const Variant::arrayType &, void *) const override
-	{
-		return nullptr;
-	}
+/**
+ * Function class providing factilities for the validation of arguments.
+ */
+class ValidatingFunction : public Function {
+private:
+	/**
+	 * List describing a valid set to arguments.
+	 */
+	Arguments arguments;
+
+	/**
+	 * Set to true if any arguments for checking were given in the constructor.
+	 * If set to false, no argument checks are performed.
+	 */
+	bool checkArguments;
+
+protected:
+	/**
+	 * Default constructor. Disables validation, all arguments are allowed.
+	 */
+	ValidatingFunction() : checkArguments(false){};
+
+	/**
+	 * Default constructor. Disables validation, all arguments are allowed.
+	 */
+	ValidatingFunction(Arguments arguments)
+	    : arguments(std::move(arguments)), checkArguments(true){};
+
+	/**
+	 * Function which cares about validating a set of arguments.
+	 *
+	 * @param args is an array containing the arguments that should be
+	 * validated.
+	 * @return the reference to the array.
+	 */
+	Variant::arrayType &validate(Variant::arrayType &args) const;
 };
 
 /**
@@ -85,7 +168,7 @@ public:
  * @tparam T is the type of the method that should be called.
  */
 template <class T>
-class Method : public Function {
+class Method : public ValidatingFunction {
 public:
 	/**
 	 * Type of the Callback function that is being called by the "call"
@@ -96,7 +179,7 @@ public:
 	 * @param thisRef is a pointer pointing at an instance of type T.
 	 * @return the return value of the function as Variant instance.
 	 */
-	using Callback = Variant (*)(const Variant::arrayType &args, T *thisRef);
+	using Callback = Variant (*)(Variant::arrayType &args, T *thisRef);
 
 private:
 	/**
@@ -104,14 +187,7 @@ private:
 	 */
 	const Callback method;
 
-public:
-	/**
-	 * Constructor of the Method class.
-	 *
-	 * @param method is a pointer at the C++ function that should be called.
-	 */
-	Method(Callback method) : method(method){};
-
+protected:
 	/**
 	 * Calls the underlying method.
 	 *
@@ -119,12 +195,31 @@ public:
 	 * to the method.
 	 * @return a Variant containing the return value.
 	 */
-	Variant call(const Variant::arrayType &args = Variant::arrayType{},
-	             void *thisRef = nullptr) const override
+	Variant doCall(Variant::arrayType &args, void *thisRef) const override
 	{
-		// Call the method
-		return method(args, static_cast<T *>(thisRef));
+		return method(validate(args), static_cast<T *>(thisRef));
 	}
+
+public:
+	/**
+	 * Constructor of the Method class with a description of the arguments that
+	 * are to be passed to the callback method.
+	 *
+	 * @param arguments is a type description restricting the arguments that are
+	 * being passed to the callback function.
+	 * @param method is the actual callback function that is being called once
+	 * the method is executed. The arguments passed to the method are validated
+	 * using the given argument descriptor.
+	 */
+	Method(Arguments arguments, Callback method)
+	    : ValidatingFunction(arguments), method(method){};
+
+	/**
+	 * Constructor of the Method class.
+	 *
+	 * @param method is a pointer at the C++ function that should be called.
+	 */
+	Method(Callback method) : method(method){};
 };
 }