From 489ec05b23b059a46839cfd7153a2bfd02eccded Mon Sep 17 00:00:00 2001 From: Abdullah Atta Date: Wed, 18 Dec 2019 10:16:33 +0500 Subject: [PATCH] eventbus: remove hacks, add sender --- examples/eventbus/eventbus.v | 4 +- .../modules/some_module/some_module.v | 10 +- vlib/eventbus/README.md | 73 +++++++----- vlib/eventbus/eventbus.v | 27 ++--- vlib/eventbus/eventbus_test.v | 66 +++++++---- vlib/eventbus/params.v | 107 ++++++------------ 6 files changed, 148 insertions(+), 139 deletions(-) diff --git a/examples/eventbus/eventbus.v b/examples/eventbus/eventbus.v index ac4c68d8aa..5480f8f299 100644 --- a/examples/eventbus/eventbus.v +++ b/examples/eventbus/eventbus.v @@ -11,6 +11,8 @@ fn main(){ some_module.do_work() } -fn on_error(p eventbus.Params) { +fn on_error(sender voidptr, p eventbus.Params) { + work := *(*some_module.Work(sender)) + println(work.hours) println(p.get_string("error")) } diff --git a/examples/eventbus/modules/some_module/some_module.v b/examples/eventbus/modules/some_module/some_module.v index 5fd501f691..6963209480 100644 --- a/examples/eventbus/modules/some_module/some_module.v +++ b/examples/eventbus/modules/some_module/some_module.v @@ -8,14 +8,20 @@ const ( eb = eventbus.new() ) +pub struct Work { + pub: + hours int +} + pub fn do_work(){ + work := Work{20} mut params := eventbus.Params{} for i in 0..20 { println("working...") if i == 15 { params.put_string("error", "CRASH!!") - eb.publish("error", params) - eb.publish("error", params) + eb.publish("error", work, params) + eb.publish("error", work, params) return } } diff --git a/vlib/eventbus/README.md b/vlib/eventbus/README.md index 57b6086808..b9e4404557 100644 --- a/vlib/eventbus/README.md +++ b/vlib/eventbus/README.md @@ -10,14 +10,14 @@ A module to provide eventing capabilities using pub/sub. **EventBus:** -1. `publish(string, Params)` - publish an event with provided Params & name +1. `publish(string, voidptr, Params)` - publish an event with provided Params & name 2. `clear_all()` - clear all subscribers 3. `has_subscriber(string)` - check if a subscriber to an event exists **Subscriber:** -1. `subscribe(string, fn(Params))` - subscribe to an event -2. `subscribe_once(string, fn(Params))` - subscribe only once to an event +1. `subscribe(string, fn(voidptr, Params))` - subscribe to an event +2. `subscribe_once(string, fn(voidptr, Params))` - subscribe only once to an event 3. `is_subscribed(string)` - check if we are subscribed to an event 4. `unsubscribe(string)` - unsubscribe from an event @@ -26,11 +26,11 @@ A module to provide eventing capabilities using pub/sub. The function given to `subscribe` and `subscribe_once` must match this: ```v -fn(Params){ +fn(voidptr, Params){ } // Example -fn onPress(p Params){ +fn onPress(sender voidptr, p Params){ //your code here... } ``` @@ -39,7 +39,7 @@ fn onPress(p Params){ For **usage across modules** [check the example](https://github.com/vlang/v/tree/master/examples/eventbus). -_Note: As a general rule, you will need to **subscribe before emitting**._ +_Note: As a general rule, you will need to **subscribe before publishing**._ **main.v** @@ -62,8 +62,13 @@ fn main(){ } // the event handler -fn on_error(p eventbus.Params) { - println(p.get_string("error")) +fn on_error(sender voidptr, p eventbus.Params) { + //cast the sender to the real type + //you can also make this mutable if required. + work := *(*Work(sender)) //a little verbose but works + + error := p.get_string("error") + println('error occured on ${work.hours}. Error: ${error}') } ``` @@ -76,12 +81,17 @@ import ( eventbus ) +struct Work{ + hours int +} + fn do_work(){ + work := Work{20} // get a mutable Params instance & put some data into it mut params := eventbus.Params{} params.put_string("error", "Error: no internet connection.") // publish the event - eb.publish("error", params) + eb.publish("error", work, params) } ``` @@ -89,38 +99,39 @@ fn do_work(){ ```v mut params := eventbus.Params{} -params.put_string("string", "vevent") + +params.put_string("string", "some_string") params.put_int("int", 20) -params.put_bool("bo", true) -//the array & map currently needs to set like this -eventbus.put_array(mut params, "array", [1,2,3]) -eventbus.put_map(mut params, "map", "", {"hello": "world"}) +params.put_bool("bool", true) -params.get_string("string") == "vevent" -params.get_int("int") == 20 -params.get_bool("bo") == true -m := params.get_string_map("map") -//the array currently needs to gotten like this -arr := eventbus.get_array(params, "array", 0) +// add maps and arrays of any type like this +arr := [1,2,3] +params.put_array("array", arr) +mp := {"hello": "world"} +params.put_map("map", mp) -//you can also pass around custom type arrays & maps (it's a little crude but works): -struct Example{} -custom_map := {"example": Example{}} -eventbus.put_map(mut params, "custom_map", Example{}, custom_map) -//and get it like this -eventbus.get_map(params, "custom_map", {"":Example{}} +//get and use the params like this +assert params.get_string("string") == "some_string" +assert params.get_int("int") == 20 +assert params.get_bool("bool") == true -//For arrays: -eventbus.put_array(mut params, "array", [Example{}]) -eventbus.get_array(params, "custom_array", Example{}) +g_arr := params.get_array("array", 0) +assert g_arr[0] == 1 + +g_m := params.get_map("map", "") +assert g_m["hello"] == "world" ``` +#### Caution when putting arrays: + +Currently putting arrays and maps directly as parameters in `put_array` doesn't work, so make a variable first and use that. + ### Notes: 1. Each `EventBus` instance has it's own registry (i.e. there is no global event registry so you can't just subscribe to an event wherever you are. 2. Each `EventBus` has a `Subscriber` instance which will need to be either exposed or you can make small public helper functions specific to your module like (`onPress`, `onError`) and etc. 3. The `eventbus` module has some helpers to ease getting/setting of Params (since V doesn't support empty interfaces yet or reflection) so use them (see usage above). -**The rationale behind separating Subscriber & Emitter:** +**The rationale behind separating Subscriber & Publisher:** -This is mainly for security because the if emitter & subscriber are both passed around, a client can easily emit events acting as the server. So a client should only be able to use the Subscriber methods. +This is mainly for security because the if publisher & subscriber are both passed around, a client can easily publish events acting as the server. So a client should only be able to use the Subscriber methods. diff --git a/vlib/eventbus/eventbus.v b/vlib/eventbus/eventbus.v index 70cd3e65a2..628556365a 100644 --- a/vlib/eventbus/eventbus.v +++ b/vlib/eventbus/eventbus.v @@ -1,6 +1,5 @@ module eventbus - pub struct Publisher { mut: registry &Registry @@ -19,11 +18,11 @@ struct Registry{ } struct EventHandler { - func fn(Params) + func fn(voidptr, Params) } pub struct EventBus{ - mut: + pub mut: registry &Registry publisher &Publisher pub: @@ -45,9 +44,9 @@ pub fn new() &EventBus{ // EventBus Methods -pub fn (eb &EventBus) publish(name string, p Params) { +pub fn (eb &EventBus) publish(name string, sender voidptr, p Params) { mut publisher := eb.publisher - publisher.publish(name, p) + publisher.publish(name, sender, p) } pub fn (eb &EventBus) clear_all(){ @@ -61,36 +60,38 @@ pub fn (eb &EventBus) has_subscriber(name string) bool { // Publisher Methods -fn (pb mut Publisher) publish(name string, p Params){ +fn (pb mut Publisher) publish(name string, sender voidptr, p Params){ + //p.put_custom("sender", "any", sender) //add sender to params for i, n in pb.registry.names { if name == n { eh := pb.registry.events[i] - invoke(eh, p) once_index := pb.registry.once.index(pb.registry.names[i]) if once_index > -1 { pb.registry.events.delete(i) pb.registry.names.delete(i) pb.registry.once.delete(once_index) } + invoke(eh, sender, p) } } } fn (p mut Publisher) clear_all(){ - for i, n in p.registry.names { + if p.registry.names.len == 0 {return} + for i := p.registry.names.len - 1; i >= 0; i-- { p.registry.delete_entry(i) } } // Subscriber Methods -pub fn (s mut Subscriber) subscribe(name string, handler fn(Params)){ +pub fn (s mut Subscriber) subscribe(name string, handler fn(voidptr, Params)){ s.registry.names << name v := voidptr(handler) s.registry.events << v } -pub fn (s mut Subscriber) subscribe_once(name string, handler fn(Params)){ +pub fn (s mut Subscriber) subscribe_once(name string, handler fn(voidptr, Params)){ s.subscribe(name, handler) s.registry.once << name } @@ -99,7 +100,7 @@ pub fn (s &Subscriber) is_subscribed(name string) bool { return s.registry.check_subscriber(name) } -pub fn (s mut Subscriber) unsubscribe(name string, handler fn(Params)){ +pub fn (s mut Subscriber) unsubscribe(name string, handler fn(voidptr, Params)){ v := voidptr(handler) for i, n in s.registry.names { if name == n { @@ -131,7 +132,7 @@ fn (r mut Registry) delete_entry(index int) { // Helper Functions -fn invoke(p voidptr, arr Params){ +fn invoke(p, sender voidptr, arr Params){ handler := EventHandler{p}.func - handler(arr) + handler(sender, arr) } diff --git a/vlib/eventbus/eventbus_test.v b/vlib/eventbus/eventbus_test.v index 17df358e60..1749a0e5be 100644 --- a/vlib/eventbus/eventbus_test.v +++ b/vlib/eventbus/eventbus_test.v @@ -5,38 +5,60 @@ import ( fn test_eventbus(){ mut eb := eventbus.new() eb.subscriber.subscribe_once("on_test", on_test) - assert eb.has_subscriber("on_test") == true - assert eb.subscriber.is_subscribed("on_test") == true + + assert eb.has_subscriber("on_test") + assert eb.subscriber.is_subscribed("on_test") + mut params := eventbus.Params{} params.put_string("eventbus", "vevent") - eb.publish("on_test", params) - assert eb.has_subscriber("on_test") == false - assert eb.subscriber.is_subscribed("on_test") == false - eb.subscriber.subscribe_once("on_test", on_test) - assert eb.has_subscriber("on_test") == true - assert eb.subscriber.is_subscribed("on_test") == true + + eb.publish("on_test", eb, params) + + assert !eb.has_subscriber("on_test") + assert !eb.subscriber.is_subscribed("on_test") + + eb.subscriber.subscribe("on_test", on_test) + + assert eb.has_subscriber("on_test") + assert eb.subscriber.is_subscribed("on_test") + eb.clear_all() - assert eb.has_subscriber("on_test") == false - assert eb.subscriber.is_subscribed("on_test") == false + + assert !eb.has_subscriber("on_test") + assert !eb.subscriber.is_subscribed("on_test") } fn test_params(){ mut params := eventbus.Params{} - params.put_string("string", "vevent") - params.put_int("int", 20) - params.put_bool("bo", true) - eventbus.put_array(mut params, "array", [1,2,3]) - eventbus.put_map(mut params, "map", "", {"hello": "world"}) - assert params.get_string("string") == "vevent" + params.put_string("string", "some_string") + params.put_int("int", 20) + params.put_bool("bool", true) + arr := [1,2,3] + params.put_array("array", arr) + mp := {"hello": "world"} + params.put_map("map", mp) + + assert params.get_string("string") == "some_string" assert params.get_int("int") == 20 - assert params.get_bool("bo") == true - arr := eventbus.get_array(params, "array", 0) - assert arr[0] == 1 - m := params.get_string_map("map") - assert m["hello"] == "world" + assert params.get_bool("bool") == true + + g_arr := params.get_array("array", 0) + assert g_arr[0] == 1 + + g_m := params.get_map("map", "") + assert g_m["hello"] == "world" } -fn on_test(p eventbus.Params) { +fn on_test(sender voidptr, p eventbus.Params) { + mut eb := *(*eventbus.EventBus(sender)) + + eb.subscriber.subscribe("on_test_2", on_test_2) + eb.clear_all() + assert !eb.has_subscriber("on_test_2") + assert !eb.subscriber.is_subscribed("on_test_2") + assert p.get_string("eventbus") == "vevent" } + +fn on_test_2(sender voidptr, p eventbus.Params){} \ No newline at end of file diff --git a/vlib/eventbus/params.v b/vlib/eventbus/params.v index 235452b183..a815938184 100644 --- a/vlib/eventbus/params.v +++ b/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(p Params, name string, def T) []T { +pub fn (p Params) get_array(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(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(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(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(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 (s T, m voidptr) array_T { + return *(*array_T(m)) +} + +fn unmarshall_map (s T, m voidptr) map_T { + return *(*map_T(m)) +} \ No newline at end of file