eventbus: remove hacks, add sender

vlib/eventbus/params.v

@@ -14,7 +14,6 @@ struct Param{
 	typ string
 	name string
 	value voidptr
-	keys voidptr
 }
 
 pub fn (p Params) get_string(name string) string {
@@ -32,68 +31,37 @@ pub fn (p Params) get_bool(name string) bool {
 	return if is_type {int(param.value) == 1}else{false}
 }
 
-pub fn get_array<T>(p Params, name string, def T) []T {
+pub fn (p Params) get_array<T>(name string, def T) []T {
+	param, is_type := p.get_param(name, "array")
+	if is_type {
+		val := param.value
+		return unmarshall_array(def, val)
+	} else {
+		return []
+	}
+}
+
+pub fn (p Params) get_map<T>(name string, def T) map[string]T {
+	param, is_type := p.get_param(name, "map")
+	if is_type {
+		val := param.value
+		return unmarshall_map(def, val)
+	} else {
+		return map[string]T
+	}
+}
+
+pub fn (p Params) get_raw(name string) voidptr {
 	param, _ := p.get_param(name, "")
-	if param.typ.contains("[") {
-		len := parse_len(param.typ, "[", "]")
-		mut b := []T
-		b = C.new_array_from_c_array_no_alloc(len, len, sizeof(T), param.value)
-		return b
-	}
-	return []
+	return param.value
 }
 
-fn C.map_set() // TODO remove hack
-
-// TODO: make this a method after generics are fixed.
-pub fn get_map<T>(p Params, name string, valueTyp T) map[string]T {
-	param, _ := p.get_param(name, "")
-	ret := map[string]T
-	if param.typ.contains("map(") {
-		len := parse_len(param.typ, "(", ")")
-		mut keys := []string
-		// the best way (that I could find) to convert voidptr into array without alloc
-		// since we know that the voidptr we are getting is an array
-		keys = C.new_array_from_c_array_no_alloc(len, len, sizeof(T), param.keys)
-		for i, key in keys {
-			//the most simple way to set map value without knowing the typ
-			// TODO remove
-			C.map_set(&ret, key, param.value + i * sizeof(T))
-		}
-	}
-	return ret
+pub fn (p mut Params) put_map(name string, value voidptr) {
+	p.put_custom(name, "map", value)
 }
 
-pub fn (p Params) get_string_map(name string) map[string]string {
-	return get_map(p, name, "")
-}
-
-pub fn (p Params) get_int_map(name string) map[string]int {
-	return get_map(p, name, 0)
-}
-
-pub fn (p Params) get_bool_map(name string) map[string]bool {
-	return get_map(p, name, false)
-}
-
-// TODO: make this a method after generics are fixed.
-pub fn put_map<T>(p mut Params, name string, valueTyp T, value map[string]T) {
-	keys := value.keys()
-	mut vals := []T
-	for key in keys {
-		vals << value[key]
- 	}
-	p.params << Param {
-		typ: "map($value.size)"
-		name: name
-		keys: keys.data
-		value: vals.data
-	}
-}
-
-// TODO: make this a method after generic methods are working.
-pub fn put_array<T>(p mut Params, name string, arr []T) {
-	p.put_custom(name, "[$arr.len]", arr.data)
+pub fn (p mut Params) put_array(name string, arr voidptr) {
+	p.put_custom(name, "array", arr)
 }
 
 pub fn (p mut Params) put_int(name string, num int) {
@@ -108,25 +76,24 @@ pub fn (p mut Params) put_bool(name string, val bool) {
 	p.put_custom(name, "bool", if val { 1 } else { 0 })
 }
 
-pub fn (p mut Params) put_custom(name string, typ string, data voidptr) {
-	p.params << Param {typ, name, data, voidptr(0)}
+pub fn (p mut Params) put_custom(name, typ string, data voidptr) {
+	p.params << Param {typ, name, data}
 }
 
 //HELPERS
-
-fn parse_len(typ, s_tok, e_tok string) int {
-	start_index := typ.index(s_tok) or { return 0 }
-	end_index := typ.index(e_tok) or { return 0 }
-	len := typ[start_index+1..end_index].int()
-	//t := typ.substr(typ.index(e_tok) + 1, typ.len)
-	return len
-}
-
 fn (p Params) get_param(name string, typ string) (Param, bool) {
 	for param in p.params {
 		if param.name == name {
 			return param, param.typ == typ
 		}
 	}
-	return Param{value: voidptr(0), keys: voidptr(0)}, false
+	return Param{value: voidptr(0)}, false
 }
+
+fn unmarshall_array<T> (s T, m voidptr) array_T {
+	return *(*array_T(m))
+}
+
+fn unmarshall_map<T> (s T, m voidptr) map_T {
+	return *(*map_T(m))
+}