Migration support

.github/workflows/build.yml

@@ -304,6 +304,7 @@ jobs:
           git fetch origin master
       - name: Check clang-format
         run: |
+          clang-format-18 --version
           git clang-format-18 --extensions c,cpp,h,hpp --style file -q --diff origin/master
           diff=$(git clang-format-18 --extensions c,cpp,h,hpp --style file -q --diff origin/master)
           echo "::error Format diff >$diff<"

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
       url: https://pypi.org/p/inkcpp-py
     permissions:
       id-token: write
-      contents: write 
+      contents: write
     steps:
       - uses: actions/checkout@v4
       - name: Download artifacts
@@ -46,4 +46,3 @@ jobs:
               --title="${GITHUB_REPOSITORY#*/} ${tag#v}" \
               --generate-notes \
               "$tag" "linux-cl.zip" "linux-lib.zip" "linux-clib.zip" "unreal_5_7.zip" "unreal_5_6.zip" "unreal_5_5.zip" "unreal_5_4.zip" "macos-cl.zip" "macos-lib.zip" "macos-clib.zip" "win64-cl.zip" "macos-arm-cl.zip" "macos-arm-lib.zip" "macos-arm-clib.zip" "win64-lib.zip" "win64-clib.zip"
-

README.md

@@ -74,7 +74,7 @@ Adapt `TargetPlatforms` as nessesarry. You might also want to install the Plugin
 Nice features for testing:
 + predefined choice selection `echo 1 2 1  | inkpp-cl -p story.(ink|json|bin)`
 + create snapshots to shorten testing:
-	+ create snapshot by entering `-1` as choice `echo 1 2 -1 | inkcpp-cl -p story.ink`
+	+ create snapshot by entering `-1` as choice `echo 1 2 -1 1 | inkcpp-cl -p story.ink`
  	+ load snapshot as an additional argument `echo 1 | inkcpp-cl -p story.snap story.ink`
 
 ## Including in C++ Code

inkcpp/CMakeLists.txt

@@ -46,6 +46,8 @@ list(
 	string_operations.cpp
 	string_operations.cpp
 	numeric_operations.cpp
+	hungarian_solver.h
+	hungarian_solver.cpp
 	casting.h
 	executioner.h
 	string_utils.h

inkcpp/array.h

@@ -20,7 +20,7 @@ namespace ink::runtime::internal
  * @tparam simple if the object has a trivial destructor, so delete[](char*) can be used instead of
  * calling the constructor.
  * @tparam dynamic if the memory should be allocated on the heap and grow if needed
- * @tparam initialCapacitiy number of elements to allocate at construction, if !dynamic, this is
+ * @tparam initial capacity number of elements to allocate at construction, if !dynamic, this is
  * allocated in place and can not be changed.
  */
 template<typename T, bool dynamic, size_t initialCapacity, bool simple>
@@ -157,6 +157,8 @@ class managed_array : public snapshot_interface
 
 	void extend(size_t capacity = 0);
 
+	bool can_be_migrated() const { return true; }
+
 	size_t snap(unsigned char* data, const snapper& snapper) const
 	{
 		inkAssert(! is_pointer<T>{}(), "here is a special case oversight");
@@ -229,6 +231,8 @@ class managed_restorable_array : public managed_array<T, dynamic, initialCapacit
 		_last_size = 0;
 	}
 
+	bool is_saved() const { return _last_size != 0; }
+
 	void save() { _last_size = this->size(); }
 
 	void forgett() { _last_size = 0; }
@@ -237,6 +241,8 @@ class managed_restorable_array : public managed_array<T, dynamic, initialCapacit
 
 	size_t last_size() const { return _last_size; }
 
+	bool can_be_migrated() const { return ! is_saved(); }
+
 	size_t snap(unsigned char* data, const snapshot_interface::snapper& snapper) const
 	{
 		unsigned char* ptr          = data;
@@ -306,7 +312,7 @@ class basic_restorable_array : public snapshot_interface
 		clear_temp();
 	}
 
-	// == Non-Copyable ==
+	// not copyable
 	basic_restorable_array(const basic_restorable_array<T>&)               = delete;
 	basic_restorable_array<T>& operator=(const basic_restorable_array<T>&) = delete;
 
@@ -315,10 +321,19 @@ class basic_restorable_array : public snapshot_interface
 
 	// get value by index
 	const T& get(size_t index) const;
+	const T& get_old(size_t index) const;
 
 	// size of the array
 	inline size_t capacity() const { return _capacity; }
 
+	inline size_t loaded_capacity() const
+	{
+		inkAssert(
+		    _loaded_capacity != static_cast<size_t>(~0), "This object was not loaded from a snapshot."
+		);
+		return _loaded_capacity;
+	}
+
 	// only const indexing is supported due to save/restore system
 	inline const T& operator[](size_t index) const { return get(index); }
 
@@ -331,6 +346,7 @@ class basic_restorable_array : public snapshot_interface
 	void clear(const T& value);
 
 	// snapshot interface
+	virtual bool                 can_be_migrated() const;
 	virtual size_t               snap(unsigned char* data, const snapper&) const;
 	virtual const unsigned char* snap_load(const unsigned char* data, const loader&);
 
@@ -358,12 +374,15 @@ class basic_restorable_array : public snapshot_interface
 	// real values live here
 	T* _array;
 
-	// we store values here when we're in save mode
+	// we store values here when we're in safe mode
 	//  they're copied on a call to forget()
 	T* _temp;
 
 	// size of both _array and _temp
 	size_t _capacity;
+	// if loaded with snap_load, this value was the original size, the current capacity might be
+	// higher
+	size_t _loaded_capacity = static_cast<size_t>(~0);
 
 	// null
 	const T _null;
@@ -389,7 +408,7 @@ inline const T& basic_restorable_array<T>::get(size_t index) const
 {
 	check_index(index);
 
-	// If we're in save mode and we have a value at that index, return that instead
+	// If we're in safe mode, and we have a value at that index, return that instead
 	if (_saved && _temp[index] != _null) {
 		return _temp[index];
 	}
@@ -398,6 +417,15 @@ inline const T& basic_restorable_array<T>::get(size_t index) const
 	return _array[index];
 }
 
+template<typename T>
+inline const T& basic_restorable_array<T>::get_old(size_t index) const
+{
+	check_index(index);
+	inkAssert(_saved, "Use old only on saved arrays.");
+
+	return _array[index];
+}
+
 template<typename T>
 inline void basic_restorable_array<T>::save()
 {
@@ -419,7 +447,7 @@ inline void basic_restorable_array<T>::forget()
 {
 	// Run through the _temp array
 	for (size_t i = 0; i < _capacity; i++) {
-		// Copy if there's values
+		// Copy if there are values
 		if (_temp[i] != _null) {
 			_array[i] = _temp[i];
 		}
@@ -521,6 +549,12 @@ class allocated_restorable_array : public basic_restorable_array<T>
 	T* _buffer;
 };
 
+template<typename T>
+inline bool basic_restorable_array<T>::can_be_migrated() const
+{
+	return ! _saved;
+}
+
 template<typename T>
 inline size_t basic_restorable_array<T>::snap(unsigned char* data, const snapper&) const
 {
@@ -542,18 +576,18 @@ inline const unsigned char*
 {
 	auto ptr = data;
 	ptr      = snap_read(ptr, _saved);
-	decltype(_capacity) capacity;
-	ptr = snap_read(ptr, capacity);
+	ptr      = snap_read(ptr, _loaded_capacity);
 	if (buffer() == nullptr) {
-		static_cast<allocated_restorable_array<T>&>(*this).resize(capacity);
+		static_cast<allocated_restorable_array<T>&>(*this).resize(_loaded_capacity);
 	}
 	inkAssert(
-	    _capacity >= capacity, "New config does not allow for necessary size used by this snapshot!"
+	    _capacity >= _loaded_capacity,
+	    "New config does not allow for necessary size used by this snapshot!"
 	);
 	T null;
 	ptr = snap_read(ptr, null);
 	inkAssert(null == _null, "null value is different to snapshot!");
-	for (size_t i = 0; i < _capacity; ++i) {
+	for (size_t i = 0; i < _loaded_capacity; ++i) {
 		ptr = snap_read(ptr, _array[i]);
 		ptr = snap_read(ptr, _temp[i]);
 	}

inkcpp/collections/restorable.h

@@ -356,6 +356,8 @@ class restorable : public snapshot_interface
 	virtual size_t       snap(unsigned char* data, const snapper&) const;
 	const unsigned char* snap_load(const unsigned char* data, const loader&);
 
+	bool can_be_migrated() const { return ! is_saved(); }
+
 protected:
 	// Called when we run out of space in buffer.
 	virtual void overflow(ElementType*&, size_t&) { inkFail("Restorable run out of memory!"); }

inkcpp/functional.cpp

@@ -53,6 +53,13 @@ float function_base::pop<float>(basic_eval_stack* stack, list_table&)
 	return casting::numeric_cast<value_type::float32>(val);
 }
 
+template<>
+double function_base::pop<double>(basic_eval_stack* stack, list_table&)
+{
+	value val = stack->pop();
+	return casting::numeric_cast<value_type::float32>(val);
+}
+
 template<>
 const char* function_base::pop<const char*>(basic_eval_stack* stack, list_table&)
 {
@@ -79,6 +86,12 @@ void function_base::push<float>(basic_eval_stack* stack, const float& v)
 	stack->push(value{}.set<value_type::float32>(v));
 }
 
+template<>
+void function_base::push<double>(basic_eval_stack* stack, const double& v)
+{
+	stack->push(value{}.set<value_type::float32>(static_cast<float>(v)));
+}
+
 template<>
 void function_base::push<bool>(basic_eval_stack* stack, const bool& v)
 {