Replaced the Callback placeholder alias with two implementations. (WORK IN PROGRESS...)

Author: Dawoodoz

Source/DFPSR/History.txt

@@ -84,4 +84,15 @@ Changes from version 0.3.0
 	* More int types were replaced with int32_t to be consistent in making the size explicit.
 		While many compilers see int and int32_t as the same type and will not complain, the names are not guaranteed to always refer to the same type.
 		Replace 'int' with 'int32_t' in your entire project if you have any problems with int types not being accepted.
-		
+	* std::function was finally replaced with the framework's own wrappers over function pointers and lambdas.
+		If you just want things to work, replace 'std::function' with 'StorableCallback' to allocate heap memory for lambda closures.
+			StorableCallback allow saving the closure outside of the original lambda's scope, and should therefore avoid capturing by reference.
+			If you don't need to capture anything, you can initialize it using a function pointer instead.
+		If you want a guarantee that there will be no heap allocation, replace 'std::function<...>' with 'const TemporaryCallback<...> &', where ... is your function interface.
+			TemporaryCallback must be passed by reference, because it can not live outside of the original lambda's scope.
+			If the compiler complains about TemporaryCallback itself being captured by value, you just pass it by reference instead like in function calls.
+		Unlike std::function, the callback types are not nullable, so instead of checking for null before calling, you simply initialize with a default action that is either doing nothing to throwing an error.
+			By not having a default constructor, there will be no extra runtime overhead to check if the function exists and you will never have to worry about null function exceptions.
+			If you see that the compiler can't find a constructor for StorableCallback and it points to a variable declaration, you need to initialize it with a function.
+		string_assignMessageHandler now uses function pointers to avoid cyclic dependencies between stringAPI.h and StorableCallback.h.
+			A message handler needs to be stored but will usually only work with global and thread-local variables.

Source/DFPSR/api/configAPI.cpp

@@ -25,7 +25,7 @@
 
 using namespace dsr;
 
-void dsr::config_parse_ini(const ReadableString& content, ConfigIniCallback receiverLambda) {
+void dsr::config_parse_ini(const ReadableString& content, const ConfigIniCallback &receiver) {
 	List<String> lines = string_split(content, U'\n');
 	String block = U"";
 	for (int32_t l = 0; l < lines.length(); l++) {
@@ -41,7 +41,7 @@ void dsr::config_parse_ini(const ReadableString& content, ConfigIniCallback rece
 		if (assignmentIndex > -1) {
 			String key = string_removeOuterWhiteSpace(string_before(command, assignmentIndex));
 			String value = string_removeOuterWhiteSpace(string_after(command, assignmentIndex));
-			receiverLambda(block, key, value);
+			receiver(block, key, value);
 		} else {
 			int32_t blockStartIndex = string_findFirst(command, U'[');
 			int32_t blockEndIndex = string_findFirst(command, U']');

Source/DFPSR/api/configAPI.h

@@ -25,12 +25,12 @@
 #define DFPSR_API_CONFIG
 
 #include "stringAPI.h"
-#include "../base/Callback.h"
+#include "../base/TemporaryCallback.h"
 
 namespace dsr {
 	// A type of function sending (block, key, value) to the caller.
 	//   One can have hard-coded options, lookup-tables, dictionaries, et cetera for looking up the given key names.
-	using ConfigIniCallback = Callback<void(const ReadableString& block, const ReadableString& key, const ReadableString& value)>;
+	using ConfigIniCallback = TemporaryCallback<void(const ReadableString& block, const ReadableString& key, const ReadableString& value)>;
 	/*
 		Parsing the given content of a *.ini configuration file.
 		Sending callbacks to receiverLambda for each key being assigned a value.
@@ -52,7 +52,7 @@ namespace dsr {
 				}
 			});
 	*/
-	void config_parse_ini(const ReadableString& content, ConfigIniCallback receiverLambda);
+	void config_parse_ini(const ReadableString& content, const ConfigIniCallback &receiver);
 
 	// Adding an ini generator might be convenient for complying with the *.ini file standard
 	// but it would also take away some artistic freedom with how lines are indented

Source/DFPSR/api/fileAPI.cpp

@@ -586,7 +586,7 @@ EntryType file_getEntryType(const ReadableString &path) {
 	return result;
 }
 
-bool file_getFolderContent(const ReadableString& folderPath, Callback<void(const ReadableString& entryPath, const ReadableString& entryName, EntryType entryType)> action) {
+bool file_getFolderContent(const ReadableString& folderPath, const TemporaryCallback<void(const ReadableString& entryPath, const ReadableString& entryName, EntryType entryType)> &action) {
 	String optimizedPath = file_optimizePath(folderPath, LOCAL_PATH_SYNTAX);
 	#ifdef USE_MICROSOFT_WINDOWS
 		String pattern = file_combinePaths(optimizedPath, U"*.*", LOCAL_PATH_SYNTAX);
@@ -639,7 +639,7 @@ bool file_getFolderContent(const ReadableString& folderPath, Callback<void(const
 	return true;
 }
 
-void file_getPathEntries(const ReadableString& path, Callback<void(ReadableString, int64_t, int64_t)> action) {
+void file_getPathEntries(const ReadableString& path, const TemporaryCallback<void(ReadableString, int64_t, int64_t)> &action) {
 	int64_t sectionStart = 0;
 	int64_t length = string_length(path);
 	for (int64_t i = 0; i < string_length(path); i++) {

Source/DFPSR/api/fileAPI.h

@@ -27,6 +27,7 @@
 #include "stringAPI.h"
 #include "bufferAPI.h"
 #include "../base/Handle.h"
+#include "../base/TemporaryCallback.h"
 #include "../settings.h"
 
 // The file API exists to save and load buffers of data for any type of file.
@@ -98,7 +99,7 @@ namespace dsr {
 	// The first entry must be something selectable to be included. Otherwise it is ignored.
 	//   C: would be returned as an entry, because other drives can be selected.
 	//   The implicit Windows drive \ and Posix system root / will not be returned, because they are implicit and can't be replaced in the path.
-	void file_getPathEntries(const ReadableString& path, Callback<void(ReadableString, int64_t, int64_t)> action);
+	void file_getPathEntries(const ReadableString& path, const TemporaryCallback<void(ReadableString, int64_t, int64_t)> &action);
 
 	// Path-syntax: Depends on pathSyntax argument.
 	// Turns / and \ into the path convention specified by pathSyntax, which is the local system's by default.
@@ -258,7 +259,7 @@ namespace dsr {
 	//               entryName equals file_getPathlessName(entryPath).
 	//               entryType equals file_getEntryType(entryPath).
 	// Post-condition: Returns true iff the folder could be found.
-	bool file_getFolderContent(const ReadableString& folderPath, Callback<void(const ReadableString& entryPath, const ReadableString& entryName, EntryType entryType)> action);
+	bool file_getFolderContent(const ReadableString& folderPath, const TemporaryCallback<void(const ReadableString& entryPath, const ReadableString& entryName, EntryType entryType)> &action);
 
 	// Path-syntax: According to the local computer.
 	// Access permissions: Default settings according to the local operating system, either inherited from the parent folder or no specific restrictions.

Source/DFPSR/api/filterAPI.h

@@ -26,7 +26,7 @@
 #define DFPSR_API_FILTER
 
 #include "../implementation/image/Image.h"
-#include "../base/Callback.h"
+#include "../base/TemporaryCallback.h"
 
 namespace dsr {
 
@@ -51,9 +51,9 @@ namespace dsr {
 //   Create images from Lambda expressions when speed is not critical.
 //     Capture images within [] and sample pixels from them using image_readPixel_border, image_readPixel_clamp and image_readPixel_tile.
 	// Lambda expressions for generating integer images.
-	using ImageGenRgbaU8 = Callback<ColorRgbaI32(int32_t x, int32_t y)>;
-	using ImageGenI32 = Callback<int32_t(int32_t x, int32_t y)>; // Used for U8 and U16 images using different saturations.
-	using ImageGenF32 = Callback<float(int32_t x, int32_t y)>;
+	using ImageGenRgbaU8 = TemporaryCallback<ColorRgbaI32(int32_t x, int32_t y)>;
+	using ImageGenI32 = TemporaryCallback<int32_t(int32_t x, int32_t y)>; // Used for U8 and U16 images using different saturations.
+	using ImageGenF32 = TemporaryCallback<float(int32_t x, int32_t y)>;
 	// In-place image generation to an existing image.
 	//   The pixel at the upper left corner gets (startX, startY) as x and y arguments to the function.
 	void filter_mapRgbaU8(const ImageRgbaU8 &target, const ImageGenRgbaU8& lambda, int32_t startX = 0, int32_t startY = 0);

Source/DFPSR/api/guiAPI.cpp

@@ -146,7 +146,7 @@ Component dsr::component_getChild(const Component& parent, int32_t childIndex) {
 	}
 }
 
-static void findAllComponentsByName(const Component& component, const ReadableString& name, Callback<void(Component, int32_t)> callback) {
+static void findAllComponentsByName(const Component& component, const ReadableString& name, const TemporaryCallback<void(Component, int32_t)> &callback) {
 	if (component_exists(component)) {
 		// Check if the current component matches
 		if (string_match(component->getName(), name)) {
@@ -159,7 +159,7 @@ static void findAllComponentsByName(const Component& component, const ReadableSt
 		}
 	}
 }
-void dsr::window_findAllComponentsByName(const Window& window, const ReadableString& name, Callback<void(Component, int32_t)> callback) {
+void dsr::window_findAllComponentsByName(const Window& window, const ReadableString& name, const TemporaryCallback<void(Component, int32_t)> &callback) {
 	MUST_EXIST(window, window_findAllComponentsByName);
 	findAllComponentsByName(window->getRootComponent(), name, callback);
 }

Source/DFPSR/api/guiAPI.h

@@ -127,7 +127,7 @@ namespace dsr {
 	// To allow detaching components while iterating over the list of children, order is reversed for child components.
 	// Raises an exception if window doesn't exist.
 	// Component names are case sensitive to reduce the risk of accidental naming conflicts among many components.
-	void window_findAllComponentsByName(const Window& window, const ReadableString& name, Callback<void(Component component, int32_t index)> callback);
+	void window_findAllComponentsByName(const Window& window, const ReadableString& name, const TemporaryCallback<void(Component component, int32_t index)> &callback);
 
 // The three main events to run in a loop at the end of the main function
 	// If the window's event queue contained any resize of the window, the canvas and the depth buffer will be replaced during this call.

Source/DFPSR/api/mediaMachineAPI.cpp

@@ -1197,7 +1197,7 @@ String machine_getOutputName(const MediaMachine& machine, int32_t methodIndex, i
 	return method->locals[method->inputCount + outputIndex].name;
 }
 
-MediaResult MediaMethod::callUsingKeywords(Callback<void(MediaMachine &machine, int32_t methodIndex, int32_t inputIndex, const ReadableString &argumentName)> setInputAction) {
+MediaResult MediaMethod::callUsingKeywords(const TemporaryCallback<void(MediaMachine &machine, int32_t methodIndex, int32_t inputIndex, const ReadableString &argumentName)> &setInputAction) {
 	if (this->methodIndex < 0 || this->methodIndex >= this->machine->methods.length()) {
 		throwError(U"Method index ", this->methodIndex, U" is out of bound 0..", this->machine->methods.length() - 1, U"\n");
 	}

Source/DFPSR/api/mediaMachineAPI.h

@@ -26,6 +26,7 @@
 
 #include "../implementation/image/Image.h"
 #include "../base/Handle.h"
+#include "../base/TemporaryCallback.h"
 #include "../math/FixedPoint.h"
 
 namespace dsr {
@@ -239,7 +240,7 @@ class MediaMethod {
 	// The function setInputAction should simply make a call to machine_setInputByIndex with the provided machine, methodIndex, inputIndex and the value corresponding to argumentName in setInputAction.
 	// If you don't recognize argumentName, then throw an exception because default input arguments are currently not implemented.
 	// Useful when the called function can be extended or reduced with only the arguments needed.
-	MediaResult callUsingKeywords(Callback<void(MediaMachine &machine, int32_t methodIndex, int32_t inputIndex, const ReadableString &argumentName)> setInputAction);
+	MediaResult callUsingKeywords(const TemporaryCallback<void(MediaMachine &machine, int32_t methodIndex, int32_t inputIndex, const ReadableString &argumentName)> &setInputAction);
 };
 
 // Post-condition: Returns a MediaMethod structure, which can be stored as a reference counting function pointer that keeps the virtual machine alive.