add support for primitive vec type generation

Author: arik-so

input/minimal_tuple.h

@@ -37,6 +37,12 @@ typedef struct LDKCVec_u8Z {
    uintptr_t datalen;
 } LDKCVec_u8Z;
 
+typedef struct LDKCVec_u16Z {
+   uint16_t *data;
+    // void *data;
+   uintptr_t datalen;
+} LDKCVec_u16Z;
+
 typedef struct LDKC2Tuple_u32ScriptZ {
    uint32_t a;
    struct LDKCVec_u8Z b;

src/generators/opaque_struct_generator.py

@@ -180,4 +180,3 @@ def generate_opaque_struct(self, struct_name, struct_details):
 			os.makedirs(output_directory)
 		with open(output_path, "w") as f:
 			f.write(mutating_output_file_contents)
-		pass

src/generators/vector_generator.py

@@ -0,0 +1,38 @@
+import re
+import os
+
+
+class VectorGenerator:
+
+	def __init__(self) -> None:
+		super().__init__()
+		template_path = f'{os.path.dirname(__file__)}/../../templates/BindingsTemplate.swift'
+		with open(template_path, 'r') as template_handle:
+			self.bindings_template = template_handle.read()
+			self.vector_template_regex = re.compile(
+				"(\/\* VECTOR_METHODS_START \*\/\n)(.*)(\n[\t ]*\/\* VECTOR_METHODS_END \*\/)",
+				flags=re.MULTILINE | re.DOTALL)
+			self.template = self.vector_template_regex.search(self.bindings_template).group(2)
+			self.mutating_vector_methods = ''
+
+	def generate_vector(self, vector_name, vector_type_details):
+		if not vector_type_details.is_primitive:
+			# TODO: add non-primitive tuple support
+			return
+		mutating_current_vector_methods = self.template
+		mutating_current_vector_methods = mutating_current_vector_methods.replace('LDKCVec_rust_primitive', vector_name)
+		mutating_current_vector_methods = mutating_current_vector_methods.replace('SwiftPrimitive',
+																				  vector_type_details.primitive_swift_counterpart)
+		self.mutating_vector_methods += "\n"+mutating_current_vector_methods+"\n"
+
+	def finalize(self):
+		filled_template = self.vector_template_regex.sub(f'\g<1>{self.mutating_vector_methods}\g<3>',
+														 self.bindings_template)
+
+		# store the output
+		output_path = f'{os.path.dirname(__file__)}/../../output/LDK/Bindings.swift'
+		output_directory = os.path.dirname(output_path)
+		if not os.path.exists(output_directory):
+			os.makedirs(output_directory)
+		with open(output_path, "w") as f:
+			f.write(filled_template)

src/lightning_header_parser.py

@@ -10,7 +10,8 @@
 class CTypes(enum.Enum):
 	OPAQUE_STRUCT = 1,
 	TUPLE = 2,
-	UNITARY_ENUM = 3
+	UNITARY_ENUM = 3,
+	VECTOR = 4
 
 
 class TypeDetails:
@@ -23,6 +24,8 @@ def __init__(self) -> None:
 		self.methods = []
 		self.constructor_method = None
 		self.free_method = None
+		self.is_primitive = False
+		self.primitive_swift_counterpart = None
 
 
 class LightningHeaderParser():
@@ -101,6 +104,7 @@ def populate_type_details(self):
 
 		self.trait_structs = set()
 		self.result_types = set()
+		self.vec_types = set()
 
 		fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
 		fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
@@ -252,6 +256,18 @@ def populate_type_details(self):
 						pass
 					elif vec_ty is not None:
 						# TODO: vector type (each one needs to be mapped)
+						self.vec_types.add(struct_name)
+						vector_type_details = None
+						if vec_ty in self.type_details:
+							vector_type_details = self.type_details[vec_ty]
+						else:
+							# it's a primitive
+							vector_type_details = TypeDetails()
+							vector_type_details.name = vec_ty
+							vector_type_details.type = CTypes.VECTOR
+							vector_type_details.is_primitive = True
+							vector_type_details.primitive_swift_counterpart = self.language_constants.c_type_map[vec_ty]
+						self.type_details[struct_name] = vector_type_details
 						pass
 					elif is_union_enum:
 						assert (struct_name.endswith("_Tag"))

src/sdk_generator.py

@@ -1,6 +1,7 @@
 from lightning_header_parser import LightningHeaderParser
 from generators.opaque_struct_generator import OpaqueStructGenerator
 from generators.tuple_generator import TupleGenerator
+from generators.vector_generator import VectorGenerator
 
 
 def parse_header() -> LightningHeaderParser:
@@ -11,6 +12,16 @@ def parse_header() -> LightningHeaderParser:
 	return header_parser
 
 
+def generate_binding_methods(parser: LightningHeaderParser):
+	# firstly, let's generate the vector utilities
+	vector_generator = VectorGenerator()
+
+	vectors = parser.vec_types
+	for current_vector in vectors:
+		vector_type_details = parser.type_details[current_vector]
+		vector_generator.generate_vector(current_vector, vector_type_details)
+	vector_generator.finalize()
+
 def generate_opaque_struct_wrappers(parser: LightningHeaderParser):
 	opaque_struct_generator = OpaqueStructGenerator()
 
@@ -31,6 +42,7 @@ def generate_tuple_wrappers(parser: LightningHeaderParser):
 
 def generate_sdk():
 	parser = parse_header()
+	generate_binding_methods(parser)
 	generate_opaque_struct_wrappers(parser)
 	generate_tuple_wrappers(parser)
 

src/swift_constants.py

@@ -10,10 +10,10 @@ def __init__(self, DEBUG: bool, target: Target, **kwargs):
         self.target = target
         self.c_array_class_caches = set()
         self.c_type_map = dict(
-            uint8_t = ['UInt8'],
-            uint16_t = ['UInt16'],
-            uint32_t = ['UInt32'],
-            uint64_t = ['UInt64'],
+            uint8_t = 'UInt8',
+            uint16_t = 'UInt16',
+            uint32_t = 'UInt32',
+            uint64_t = 'UInt64',
         )
 
         self.to_hu_conv_templates = dict(

templates/BindingsTemplate.swift

@@ -0,0 +1,34 @@
+//
+//  Bindings.swift
+//  LDKSwiftARC
+//
+//  Created by Arik Sosman on 3/23/21.
+//
+
+import Foundation
+
+class Bindings{
+
+	/* VECTOR_METHODS_START */
+	static func new_LDKCVec_rust_primitive(array: [SwiftPrimitive]) -> LDKCVec_rust_primitive {
+
+        let dataContainer = array.withUnsafeBufferPointer { (pointer: UnsafeBufferPointer<SwiftPrimitive>) -> UnsafeMutablePointer<SwiftPrimitive> in
+            let mutablePointer = UnsafeMutablePointer<SwiftPrimitive>(mutating: pointer.baseAddress!)
+            return mutablePointer
+        }
+
+        let vector = LDKCVec_rust_primitive(data: dataContainer, datalen: UInt(array.count))
+        return vector
+
+    }
+
+    static func LDKCVec_rust_primitive_to_array(vector: LDKCVec_rust_primitive) -> [SwiftPrimitive] {
+		var array = [SwiftPrimitive]()
+		for index in 0..<Int(vector.datalen) {
+			array.append(vector.data[index])
+		}
+		return array
+	}
+	/* VECTOR_METHODS_END */
+
+}