From a89e744ed0e8c759caf041a580112365bbfe4303 Mon Sep 17 00:00:00 2001
From: radiohotline <radoihotline@disroot.rg>
Date: Tue, 25 Aug 2026 16:33:56 +0300
Subject: escoria update

---
 addons/gdUnit4/src/core/GdArrayTools.gd | 127 ++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 addons/gdUnit4/src/core/GdArrayTools.gd

(limited to 'addons/gdUnit4/src/core/GdArrayTools.gd')

diff --git a/addons/gdUnit4/src/core/GdArrayTools.gd b/addons/gdUnit4/src/core/GdArrayTools.gd
new file mode 100644
index 0000000..74f0e17
--- /dev/null
+++ b/addons/gdUnit4/src/core/GdArrayTools.gd
@@ -0,0 +1,127 @@
+## Small helper tool to work with Godot Arrays
+class_name GdArrayTools
+extends RefCounted
+
+
+const max_elements := 32
+const ARRAY_TYPES := [
+	TYPE_ARRAY,
+	TYPE_PACKED_BYTE_ARRAY,
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY
+]
+
+
+static func is_array_type(value: Variant) -> bool:
+	return is_type_array(typeof(value))
+
+
+static func is_type_array(type :int) -> bool:
+	return  type in ARRAY_TYPES
+
+
+## Filters an array by given value[br]
+## If the given value not an array it returns null, will remove all occurence of given value.
+static func filter_value(array: Variant, value: Variant) -> Variant:
+	if not is_array_type(array):
+		return null
+
+	@warning_ignore("unsafe_method_access")
+	var filtered_array: Variant = array.duplicate()
+	@warning_ignore("unsafe_method_access")
+	var index: int = filtered_array.find(value)
+	while index != -1:
+		@warning_ignore("unsafe_method_access")
+		filtered_array.remove_at(index)
+		@warning_ignore("unsafe_method_access")
+		index = filtered_array.find(value)
+	return filtered_array
+
+
+## Groups an array by a custom key selector
+## The function should take an item and return the group key
+static func group_by(array: Array, key_selector: Callable) -> Dictionary:
+	var result := {}
+
+	for item: Variant in array:
+		var group_key: Variant = key_selector.call(item)
+		var values: Array = result.get_or_add(group_key, [])
+		values.append(item)
+
+	return result
+
+
+## Erases a value from given array by using equals(l,r) to find the element to erase
+static func erase_value(array :Array, value :Variant) -> void:
+	for element :Variant in array:
+		if GdObjects.equals(element, value):
+			array.erase(element)
+
+
+## Scans for the array build in type on a untyped array[br]
+## Returns the buildin type by scan all values and returns the type if all values has the same type.
+## If the values has different types TYPE_VARIANT is returend
+static func scan_typed(array :Array) -> int:
+	if array.is_empty():
+		return TYPE_NIL
+	var actual_type := GdObjects.TYPE_VARIANT
+	for value :Variant in array:
+		var current_type := typeof(value)
+		if not actual_type in [GdObjects.TYPE_VARIANT, current_type]:
+			return GdObjects.TYPE_VARIANT
+		actual_type = current_type
+	return actual_type
+
+
+## Converts given array into a string presentation.[br]
+## This function is different to the original Godot str(<array>) implementation.
+## The string presentaion contains fullquallified typed informations.
+##[br]
+## Examples:
+## 	[codeblock]
+##		# will result in PackedString(["a", "b"])
+## 		GdArrayTools.as_string(PackedStringArray("a", "b"))
+##		# will result in PackedString(["a", "b"])
+##		GdArrayTools.as_string(PackedColorArray(Color.RED, COLOR.GREEN))
+## 	[/codeblock]
+static func as_string(elements: Variant, encode_value := true) -> String:
+	var delemiter := ", "
+	if elements == null:
+		return "<null>"
+	@warning_ignore("unsafe_cast")
+	if (elements as Array).is_empty():
+		return "<empty>"
+	var prefix := _typeof_as_string(elements) if encode_value else ""
+	var formatted := ""
+	var index := 0
+	for element :Variant in elements:
+		if max_elements != -1 and index > max_elements:
+			return prefix + "[" + formatted + delemiter + "...]"
+		if formatted.length() > 0 :
+			formatted += delemiter
+		formatted += GdDefaultValueDecoder.decode(element) if encode_value else str(element)
+		index += 1
+	return prefix + "[" + formatted + "]"
+
+
+static func has_same_content(current: Array, other: Array) -> bool:
+	if current.size() != other.size(): return false
+	for element: Variant in current:
+		if not other.has(element): return false
+		if current.count(element) != other.count(element): return false
+	return true
+
+
+static func _typeof_as_string(value :Variant) -> String:
+	var type := typeof(value)
+	# for untyped array we retun empty string
+	if type == TYPE_ARRAY:
+		return ""
+	return GdObjects.typeof_as_string(value)
-- 
cgit v1.3