def build_spawn(cls, i, ex, args, meta_args): """Spawn an entity into the scene""" ex.get_spawn_entity = hive.socket(cls.set_spawn_entity, "entity.spawn") # Associate entity with this hive so it is safely destroyed ex.get_register_destructor = hive.socket(cls.set_register_destructor, "entity.register_destructor") ex.on_entity_process_instantiated = hive.plugin( cls.on_entity_process_created, "bind.on_created") i.entity_class_id = hive.property(cls, "entity_class_id", "str.entity_class_id") i.pull_class_id = hive.pull_in(i.entity_class_id) ex.entity_class_id = hive.antenna(i.pull_class_id) i.entity_last_created_id = hive.property(cls, "entity_last_created_id", "int.entity_id") if meta_args.spawn_hive: i.pull_entity_id = hive.pull_out(i.entity_last_created_id) ex.entity_last_created_id = hive.output(i.pull_entity_id) else: i.push_entity_id = hive.push_out(i.entity_last_created_id) ex.created_entity_id = hive.output(i.push_entity_id) i.do_spawn = hive.triggerable(cls.do_spawn_entity) i.trigger = hive.triggerfunc(i.do_spawn) i.on_triggered = hive.triggerable(i.trigger) hive.trigger(i.trigger, i.pull_class_id, pretrigger=True) # Process instantiator if meta_args.spawn_hive: i.instantiator = Instantiator(forward_events='all', bind_process='child') # Pull entity to instantiator hive.connect(i.pull_entity_id, i.instantiator.entity_id) # Get last created ex.hive_class = hive.antenna(i.instantiator.hive_class) ex.last_process_id = hive.output(i.instantiator.last_process_id) ex.stop_process = hive.antenna(i.instantiator.stop_process) ex.pause_events = hive.antenna(i.instantiator.pause_events) ex.resume_events = hive.antenna(i.instantiator.resume_events) # Instantiate hive.trigger(i.trigger, i.instantiator.create) else: # Finally push out entity hive.trigger(i.trigger, i.push_entity_id) ex.spawn = hive.entry(i.on_triggered)
def build_server(cls, i, ex, args): i.local_address = hive.property(cls, "local_address", "tuple") i.push_bind_address = hive.push_in(i.local_address) ex.bind_to = hive.antenna(i.push_bind_address) i.do_bind = hive.triggerable(cls.do_bind) hive.trigger(i.push_bind_address, i.do_bind) # Receiving connection i.connected_address = hive.property(cls, "connected_address", "tuple") i.push_connected_address = hive.push_out(i.connected_address) ex.on_client_connected = hive.output(i.push_connected_address) # Receiving connection i.disconnected_address = hive.property(cls, "disconnected_address", "tuple") i.push_disconnected_address = hive.push_out(i.disconnected_address) ex.on_client_disconnected = hive.output(i.push_disconnected_address) # Receiving i.from_address = hive.property(cls, "from_address", "tuple") i.pull_from_address = hive.pull_out(i.from_address) ex.from_address = hive.output(i.pull_from_address) i.received_data = hive.property(cls, "received_data", "bytes") i.push_received = hive.push_out(i.received_data) ex.on_received = hive.output(i.push_received) # Hive callbacks i.on_disconnected = hive.triggerfunc() i.on_connected = hive.triggerfunc() i.on_received = hive.triggerfunc() hive.trigger(i.on_received, i.push_received) hive.trigger(i.on_connected, i.push_connected_address) hive.trigger(i.on_disconnected, i.push_disconnected_address) # Sending i.to_address = hive.property(cls, "to_address", "tuple") i.pull_to_address = hive.pull_in(i.to_address) ex.to_address = hive.antenna(i.pull_to_address) i.outgoing_data = hive.property(cls, "outgoing_data", "bytes") i.push_outgoing_data = hive.push_in(i.outgoing_data) ex.send = hive.antenna(i.push_outgoing_data) i.do_send_data = hive.triggerable(cls.do_send) hive.trigger(i.push_outgoing_data, i.pull_to_address, pretrigger=True) hive.trigger(i.push_outgoing_data, i.do_send_data) i.synchronise_data = hive.triggerable(cls.synchronise) i.on_tick = OnTick() hive.connect(i.on_tick.on_tick, i.synchronise_data)
def build_tick(cls, i, ex, args): """Tick event sensor, trigger on_tick every tick""" i.on_tick = hive.triggerfunc() ex.on_tick = hive.hook(i.on_tick) ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler", policy=hive.SingleRequired) ex.get_remove_handler = hive.socket(cls.set_remove_handler, "event.remove_handler", policy=hive.SingleRequired) i.enable = hive.triggerable(cls.enable) ex.enable = hive.entry(i.enable) i.disable = hive.triggerable(cls.disable) ex.disable = hive.entry(i.disable)
def build_process(cls, i, ex, args): # Startup / End callback ex.get_on_started = hive.socket(cls.add_on_started, identifier="on_started", policy=hive.MultipleOptional) ex.get_on_stopped = hive.socket(cls.add_on_stopped, identifier="on_stopped", policy=hive.MultipleOptional) i.on_started = hive.triggerable(cls.start) i.on_stopped = hive.triggerable(cls.stop) ex.on_started = hive.entry(i.on_started) ex.on_stopped = hive.entry(i.on_stopped)
def build_commandline(cls, i, ex, args): i.start = h.triggerable(cls.start) i.stop = h.triggerable(cls.stop) i.flush = h.triggerable(cls.flush) prop_command = h.property(cls, "command", "str") i.push_command = h.push_out(prop_command) ex.prop_command = prop_command ex.command = h.output(i.push_command) ex.send_command = cls.send_command ex.start = h.entry(i.start) ex.flush = h.entry(i.flush) ex.stop = h.entry(i.stop) ex.listen = h.socket(cls.add_listener)
def build_move(cls, i, ex, args, meta_args): """Apply a position delta to an entity""" coordinate_system = meta_args.coordinate_system i.displacement = hive.property(cls, "displacement", "vector") i.pull_displacement = hive.pull_in(i.displacement) ex.displacement = hive.antenna(i.pull_displacement) if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_entity_id = hive.triggerable(cls.do_get_entity_id) hive.trigger(i.pull_displacement, i.do_get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) hive.trigger(i.pull_displacement, i.pull_entity_id) if coordinate_system == 'absolute': ex.get_set_position = hive.socket( cls.set_set_position, identifier="entity.position.set.absolute") ex.get_get_position = hive.socket( cls.set_get_position, identifier="entity.position.get.absolute") i.do_set_position = hive.triggerable(cls.do_move_absolute) else: i.other_entity_id = hive.property(cls, "other_entity_id", "int.entity_id") i.pull_other_entity_id = hive.pull_in(i.other_entity_id) ex.other_entity_id = hive.antenna(i.pull_other_entity_id) hive.trigger(i.pull_displacement, i.pull_other_entity_id) ex.get_set_position = hive.socket( cls.set_set_position, identifier="entity.position.set.relative") ex.get_get_position = hive.socket( cls.set_get_position, identifier="entity.position.get.relative") i.do_set_position = hive.triggerable(cls.do_move_relative) hive.trigger(i.pull_displacement, i.do_set_position) ex.trig = hive.entry(i.pull_displacement)
def build_mainloop(cls, i, ex, args): i.event_manager = EventManager(export_namespace=True) i.input_manager = InputHandler(export_namespace=True) i.entity_manager = EntityManager(export_namespace=True) i.transform_manager = TransformManager(export_namespace=True) i.physics_manager = PhysicsManager(export_namespace=True) # Connect input manager hive.connect(i.tick, i.input_manager.update) hive.connect(i.input_manager.event, i.event_manager.event_in) # Connect physics hive.connect(i.tick, i.physics_manager.tick) hive.connect(i.pull_tick_rate, i.physics_manager.tick_rate) # Send tick event and step Panda i.on_tick = hive.triggerable(cls.on_tick) hive.trigger(i.tick, i.on_tick) # Get read event ex.get_dispatcher = hive.socket(cls.set_event_dispatcher, "event.process") ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler") # Add startup and stop callbacks ex.main_on_started = hive.plugin(cls.on_started, identifier="on_started")
def build_keyboard(cls, i, ex, args, meta_args): """Listen for keyboard event""" if meta_args.mode == 'single key': ex.on_event = hive.socket(cls.add_single_listener, identifier="event.add_handler") args.key = hive.parameter("str.keycode", "w") i.key = hive.property(cls, "key", "str.keycode", args.key) i.push_key = hive.push_in(i.key) ex.key = hive.antenna(i.push_key) i.on_key_changed = hive.triggerable(cls.change_listener_keys) hive.trigger(i.push_key, i.on_key_changed) i.on_pressed = hive.triggerfunc() ex.on_pressed = hive.hook(i.on_pressed) i.on_released = hive.triggerfunc() ex.on_released = hive.hook(i.on_released) i.is_pressed = hive.property(cls, "is_pressed", "bool") i.pull_is_pressed = hive.pull_out(i.is_pressed) ex.is_pressed = hive.output(i.pull_is_pressed) else: ex.on_event = hive.socket(cls.add_any_listener, identifier="event.add_handler") i.key_pressed = hive.property(cls, 'key_pressed', data_type='str.keycode') i.pull_key_pressed = hive.push_out(i.key_pressed) ex.key_pressed = hive.output(i.pull_key_pressed) i.key_released = hive.property(cls, 'key_released', data_type='str.keycode') i.pull_key_released = hive.push_out(i.key_released) ex.key_released = hive.output(i.pull_key_released)
def build_input_handler(cls, i, ex, args): i.update = hive.triggerable(cls.update) ex.update = hive.entry(i.update) i.event = hive.property(cls, "event", "tuple") i.push_event = hive.push_out(i.event) ex.event = hive.output(i.push_event)
def build_foreach(i, ex, args, meta_args): """Iterate over iterable object""" # Set iterable i.iterable = hive.variable("$iterable[int]") i.pull_iterable = hive.pull_in(i.iterable) ex.iterable = hive.antenna(i.pull_iterable) i.do_trig = hive.triggerfunc() i.trig_in = hive.triggerable(i.do_trig) ex.start = hive.entry(i.trig_in) i.break_ = hive.variable('bool', False) i.item = hive.variable(meta_args.data_type) i.push_item = hive.push_out(i.item) ex.item = hive.output(i.push_item) i.index = hive.variable('int', 0) i.pull_index = hive.pull_out(i.index) ex.index = hive.output(i.pull_index) i.finished = hive.triggerfunc() i.do_break = hive.modifier(do_break) ex.break_ = hive.entry(i.do_break) ex.finished = hive.hook(i.finished) i.iter = hive.modifier(do_iter) hive.trigger(i.do_trig, i.pull_iterable) hive.trigger(i.do_trig, i.iter)
def build_instantiator(cls, i, ex, args, meta_args): """Instantiates a Hive class at runtime""" # If this is built now, then it won't perform matchmaking, so use meta hive bind_meta_class = hive.meta_hive("BindEnvironment", build_bind_environment, declare_build_environment, builder_cls=BindEnvironmentClass) #assert bind_meta_class._hive_object_class i.bind_meta_class = hive.property(cls, "bind_meta_class", "class", bind_meta_class) i.trig_instantiate = hive.triggerfunc(cls.instantiate) i.do_instantiate = hive.triggerable(i.trig_instantiate) i.hive_class = hive.property(cls, "hive_class", "class") i.pull_hive_class = hive.pull_in(i.hive_class) ex.hive_class = hive.antenna(i.pull_hive_class) ex.create = hive.entry(i.do_instantiate) hive.trigger(i.trig_instantiate, i.pull_hive_class, pretrigger=True) ex.process_id = hive.property(cls, "last_created_process_id", "int.process_id") i.pull_process_id = hive.pull_out(ex.process_id) ex.last_process_id = hive.output(i.pull_process_id) i.push_stop_process = hive.push_in(cls.stop_hive) ex.stop_process = hive.antenna(i.push_stop_process) # Bind class plugin ex.bind_on_created = hive.socket(cls.add_on_created, identifier="bind.on_created", policy=hive.MultipleOptional) ex.add_get_plugins = hive.socket(cls.add_get_plugins, identifier="bind.get_plugins", policy=hive.MultipleOptional) ex.add_get_config = hive.socket(cls.add_get_config, identifier="bind.get_config", policy=hive.MultipleOptional) # Bind instantiator if meta_args.bind_process == 'child': # Add startup and stop callbacks ex.on_stopped = hive.plugin(cls.stop_all_processes, identifier="on_stopped")
def build_watch(cls, i, ex, args, meta_args): """Watch value and indicate when it is changed. Uses a tick callback. """ args.start_value = hive.parameter(meta_args.data_type, None) i.value = hive.property(cls, "current_value", meta_args.data_type, args.start_value) if meta_args.mode == 'pull': i.value_in = hive.pull_in(i.value) else: i.value_in = hive.push_in(i.value) ex.value = hive.antenna(i.value_in) i.on_changed = hive.triggerfunc() ex.on_changed = hive.hook(i.on_changed) if meta_args.mode == 'pull': ex.get_add_handler = hive.socket(cls.set_add_handler, identifier="event.add_handler") else: i.compare_values = hive.triggerable(cls.compare_values) hive.trigger(i.value_in, i.compare_values)
def test_callable_triggerfunc(): """Trigger function will trigger associated triggerable, after first calling triggerfunc wrapped function""" hive_ping = hive.triggerfunc(print_ping) hive_pong = hive.triggerable(print_pong) hive.trigger(hive_ping, hive_pong) hive_ping()
def test_empty_triggerfunc(): """Trigger function will trigger associated triggerable""" hive_pang = hive.triggerfunc() hive_pong = hive.triggerable(print_pong) hive.trigger(hive_pang, hive_pong) hive_pang()
def build_mainloop(cls, i, ex, args): """Blocking fixed-timestep trigger generator""" i.tick = hive.triggerfunc() i.stop = hive.triggerable(cls.stop) i.run = hive.triggerable(cls.run) ex.tick = hive.hook(i.tick) ex.run = hive.entry(i.run) ex.stop = hive.entry(i.stop) i.tick_rate = hive.property(cls, "tick_rate", 'int') i.pull_tick_rate = hive.pull_out(i.tick_rate) ex.tick_rate = hive.output(i.pull_tick_rate) ex.get_tick_rate = hive.plugin(cls.get_tick_rate, identifier="app.get_tick_rate") ex.quit = hive.plugin(cls.stop, identifier="app.quit")
def build_bind_environment(cls, i, ex, args, meta_args): """Provides plugins to new embedded hive instance""" ex.hive = meta_args.hive_class() # Startup / End callback ex.get_on_started = hive.socket(cls.add_on_started, identifier="on_started", policy=hive.MultipleOptional) ex.get_on_stopped = hive.socket(cls.add_on_stopped, identifier="on_stopped", policy=hive.MultipleOptional) i.on_started = hive.triggerable(cls.start) i.on_stopped = hive.triggerable(cls.stop) ex.on_started = hive.entry(i.on_started) ex.on_stopped = hive.entry(i.on_stopped) i.state = hive.property(cls, 'state', 'str') i.pull_state = hive.pull_out(i.state) ex.state = hive.output(i.pull_state)
def build_dog(cls, i, ex, args): i.call = hive.triggerfunc(cls.call) i.woof = hive.triggerable(cls.woof) hive.trigger(i.call, i.woof) i.bark = hive.triggerfunc() hive.trigger(i.bark, i.woof) i.woof_only = hive.triggerable(cls.woof) i.woofed = hive.triggerfunc() ex.woofs = hive.property(cls, "woofs") ex.woof = hive.entry(i.woof) ex.woof_only = hive.entry(i.woof_only) ex.woofed = hive.hook(i.woofed) ex.bark = hive.hook(i.bark) ex.call = hive.hook(i.call)
def build_dispatch(cls, i, ex, args): i.event = hive.property(cls, "event", "tuple.event") i.pull_event = hive.pull_in(i.event) ex.event = hive.antenna(i.pull_event) ex.get_read_event = hive.socket(cls.set_read_event, identifier="event.process") i.dispatch = hive.triggerable(cls.dispatch) ex.trig = hive.entry(i.dispatch)
def build_this(cls, i, ex, args): """Access to current bound entity""" ex.get_bound_entity = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_out(i.entity_id) ex.entity_id = hive.output(i.pull_entity_id) i.do_get_entity_id = hive.triggerable(cls.get_entity_id) hive.trigger(i.pull_entity_id, i.do_get_entity_id, pretrigger=True)
def build_animation(cls, i, ex, args, meta_args): """Play animation for actor""" i.do_start = hive.triggerable(cls.start) i.do_stop = hive.triggerable(cls.stop) ex.start = hive.entry(i.do_start) ex.stop = hive.entry(i.do_stop) i.current_frame = hive.property(cls, "current_frame", "int") i.end_frame = hive.property(cls, "end_frame", "int") i.start_frame = hive.property(cls, "start_frame", "int") i.pull_current_frame = hive.pull_out(i.current_frame) i.pull_end_frame = hive.pull_in(i.end_frame) i.pull_start_frame = hive.pull_in(i.start_frame) ex.current_frame = hive.output(i.pull_current_frame) ex.start_frame = hive.antenna(i.pull_start_frame) ex.end_frame = hive.antenna(i.pull_end_frame)
def build_event_environment(cls, i, ex, args, meta_args): """Runtime event environment for instantiated hive. Provides appropriate sockets and plugins for event interface """ ex.add_handler = hive.plugin(cls.add_handler, identifier="event.add_handler") ex.remove_handler = hive.plugin(cls.remove_handler, identifier="event.remove_handler") ex.read_event = hive.plugin(cls.handle_event, identifier="event.process") ex.event_on_stopped = hive.plugin(cls.on_closed, identifier="on_stopped", policy=hive.SingleOptional) i.pause_events = hive.triggerable(cls.pause) ex.pause_events = hive.entry(i.pause_events) i.resume_events = hive.triggerable(cls.resume) ex.resume_events = hive.entry(i.resume_events)
def build_tag(cls, i, ex, args, meta_args): """Access to entity tag API""" if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_bound_entity_id = hive.triggerable(cls.get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) i.do_get_bound_entity_id = hive.triggerable(i.pull_entity_id) i.tag_name = hive.property(cls, "tag_name", "str") i.tag_value = hive.property(cls, "tag_value", meta_args.data_type) i.pull_tag_name = hive.pull_in(i.tag_name) ex.name = hive.antenna(i.pull_tag_name) if meta_args.mode == 'get': ex.get_get_tag = hive.socket(cls.set_get_tag, identifier="entity.tag.get") i.pull_tag_value = hive.pull_out(i.tag_value) ex.value = hive.output(i.pull_tag_value) i.do_get_tag = hive.triggerable(cls.get_tag) hive.trigger(i.pull_tag_value, i.do_get_bound_entity_id) hive.trigger(i.pull_tag_value, i.pull_tag_name) hive.trigger(i.pull_tag_value, i.do_get_tag) else: ex.get_set_tag = hive.socket(cls.set_set_tag, identifier="entity.tag.set") i.push_tag_value = hive.push_in(i.tag_value) ex.value = hive.antenna(i.push_tag_value) i.do_get_tag = hive.triggerable(cls.get_tag) hive.trigger(i.push_tag_value, i.do_get_bound_entity_id) hive.trigger(i.push_tag_value, i.pull_tag_name) hive.trigger(i.push_tag_value, i.do_get_tag)
def build_chessboard(cls, i, ex, args): prop_move = h.property(cls, "prop_move", "str") # TODO: make buffer i.make_move = h.push_in(prop_move) i.trig_make_move = h.triggerable(cls.trig_make_move) # TODO: make modifier h.trigger(i.make_move, i.trig_make_move) ex.make_move = h.antenna(i.make_move) ex.do_make_move = cls.make_move ex.p_make_move = h.plugin(cls.make_move) ex.prop_move = prop_move ex.set_turn = h.socket(cls.set_turn) ex.add_moveprocessor = h.socket(cls.add_moveprocessor)
def build_destroy(cls, i, ex, args, meta_args): """Destroy an entity""" i.trig_destroy = hive.triggerfunc(cls.destroy) i.do_destroy = hive.triggerable(i.trig_destroy) ex.destroy = hive.entry(i.do_destroy) if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_entity_id = hive.triggerable(cls.do_get_entity_id) hive.trigger(i.trig_destroy, i.do_get_entity_id, pretrigger=True) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) hive.trigger(i.trig_destroy, i.pull_entity_id, pretrigger=True) ex.get_destroy_entity = hive.socket(cls.set_destroy_entity, identifier="entity.destroy")
def build_house(cls, i, ex, args): i.brutus = dog("Brutus") i.fifi = dog("Fifi") i.dog_comes = h.triggerable(cls.dog_comes) h.trigger(i.brutus.call, i.dog_comes) i.mail = h.triggerfunc(cls.mail) h.trigger(i.mail, i.fifi.woof) ex.brutus = i.brutus ex.fifi = i.fifi ex.mail = h.hook(i.mail) ex.dog_comes = h.entry(i.dog_comes)
def build_import(cls, i, ex, args): """Interface to python import mechanism, with respect to editor project path""" i.import_path = hive.property(cls, "import_path", 'str') i.pull_import_path = hive.pull_in(i.import_path) ex.import_path = hive.antenna(i.pull_import_path) i.do_import = hive.triggerable(cls.do_import_from_path) i.module = hive.property(cls, "module", "module") i.pull_module = hive.pull_out(i.module) ex.module = hive.output(i.pull_module) hive.trigger(i.pull_module, i.pull_import_path, pretrigger=True) hive.trigger(i.pull_module, i.do_import, pretrigger=True)
def build_house(cls, i, ex, args): i.brutus_ = DogHive("Brutus") i.fifi = DogHive("Fifi") i.dog_appeared = hive.triggerable(cls.dog_appeared) hive.trigger(i.brutus_.call, i.dog_appeared) i.mail_arrived = hive.triggerfunc(cls.mail_arrived) hive.trigger(i.mail_arrived, i.fifi.woof) ex.brutus = i.brutus_ ex.fifi = i.fifi ex.mail_arrived = hive.hook(i.mail_arrived) ex.dog_appeared = hive.entry(i.dog_appeared)
def build_parent(cls, i, ex, args, meta_args): """Set/Get entity parent""" ex.get_get_parent = hive.socket(cls.set_get_parent, identifier="entity.parent.get") ex.get_set_parent = hive.socket(cls.set_set_parent, identifier="entity.parent.set") i.parent_id = hive.property(cls, "parent_id", "int.entity_id") if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_bound_entity_id = hive.triggerable(cls.get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) i.do_get_bound_entity_id = hive.triggerable(i.pull_entity_id) if meta_args.mode == "get": i.pull_parent_id = hive.pull_out(i.parent_id) ex.parent_id = hive.output(i.pull_parent_id) i.get_parent_id = hive.triggerable(cls.get_parent_id) hive.trigger(i.pull_parent_id, i.do_get_bound_entity_id, pretrigger=True) hive.trigger(i.pull_parent_id, i.get_parent_id, pretrigger=True) else: i.push_parent_id = hive.push_in(i.parent_id_id) ex.parent_id = hive.antenna(i.push_parent_id) i.set_parent = hive.triggerable(cls.set_parent) hive.trigger(i.push_parent_id, i.do_get_bound_entity_id) hive.trigger(i.push_parent_id, i.set_parent)
def build_server(cls, i, ex, args): i.connect_address = hive.property(cls, "server_address", "tuple") i.push_connect = hive.push_in(i.connect_address) ex.connect_to = hive.antenna(i.push_connect) i.do_connect = hive.triggerable(cls.do_connect) hive.trigger(i.push_connect, i.do_connect) # Hive callbacks i.on_disconnected = hive.triggerfunc() i.on_connected = hive.triggerfunc() i.on_received = hive.triggerfunc() # Receiving connection ex.on_connected = hive.hook(i.on_connected) # Lost connection ex.on_disconnected = hive.hook(i.on_disconnected) # Receiving i.received_data = hive.property(cls, "received_data", "bytes") i.push_received = hive.push_out(i.received_data) ex.on_received = hive.output(i.push_received) hive.trigger(i.on_received, i.push_received) # Sending i.outgoing_data = hive.property(cls, "outgoing_data", "bytes") i.push_outgoing_data = hive.push_in(i.outgoing_data) ex.send = hive.antenna(i.push_outgoing_data) i.do_send_data = hive.triggerable(cls.do_send) hive.trigger(i.push_outgoing_data, i.do_send_data) i.synchronise_data = hive.triggerable(cls.synchronise) i.on_tick = OnTick() hive.connect(i.on_tick.on_tick, i.synchronise_data)
def build_dictionary(cls, i, ex, args, meta_args): """Interface to dictionary object""" ex.dict = hive.property(cls, "dict", "dict") i.dict_in = hive.push_in(ex.dict) ex.dict_ = hive.antenna(i.dict_in) i.dict_out = hive.pull_out(ex.dict) ex.dict_out = hive.output(i.dict_out) i.key = hive.property(cls, "key", meta_args.key_data_type) i.value = hive.property(cls, "value", meta_args.data_type) # Setitem i.set_key_in = hive.pull_in(i.key) ex.set_key = hive.antenna(i.set_key_in) i.in_value = hive.push_in(i.value) ex.in_value = hive.antenna(i.in_value) i.set_value = hive.triggerable(cls.set_value) hive.trigger(i.in_value, i.set_key_in) hive.trigger(i.set_key_in, i.set_value) i.get_key_in = hive.pull_in(i.key) ex.get_key = hive.antenna(i.get_key_in) i.out_value = hive.pull_out(i.value) ex.out_value = hive.output(i.out_value) i.get_value = hive.triggerable(cls.get_value) # Before outputting, update key hive.trigger(i.out_value, i.get_key_in, pretrigger=True) hive.trigger(i.get_key_in, i.get_value)