Subscribable Event

Module — 2 files

These files compile together (same module folder).

file_1.verse

using { /Verse.org/Concurrency }

subscribable_event<public>(t:type) := class(subscribable(t), signalable(t)):

    var Callbacks<private>:[]tuple(type{_(:t):void}, int) = array{}
    var NextID<private>:int = 0
    
    Signal<override>(Payload:t):void =
        for (Callback : Callbacks) do Callback(0)(Payload)

    Subscribe<override>(Callback:type{_(:t):void})<transacts>:cancelable =
        ID := NextID
        set NextID += 1
        set Callbacks += array{(Callback, ID)}
        return basic_cancelable:
            ID := ID
            CancelCallback := CancelSubscription

    CancelAllSubscriptions<public>()<transacts>:void =
        set Callbacks = array{}

    CancelSubscription<private>(ID:int)<transacts>:void =
        set Callbacks = for (Callback : Callbacks, Callback(1) <> ID) do Callback

listenable_event<public>(t:type) := class(subscribable_event(t), listenable(t)):

    Event<private>:event(t) = event(t){}

    Await<override>()<suspends>:t = Event.Await()

    Signal<override>(Payload:t):void =
        (super:)Signal(Payload)
        Event.Signal(Payload)

basic_cancelable<internal> := class(cancelable):

    ID<internal>:int
    CancelCallback<internal>:type{_(:int)<transacts>:void}

    Cancel<override>()<transacts>:void =
        CancelCallback(ID)

event_signaller_device.verse

event_signaller_device := class(creative_device):
    
    # If you want to expose only the listenable (or subscribable) interface to prevent the possibility of signalling it from anywhere else:
    # PlayerJoinedGameEvent<public>():listenable(tuple(player, int)) = PlayerJoinedGameEventInternal
    # PlayerJoinedGameEventInternal<private>:listenable_event(tuple(player, int)) = listenable_event(tuple(player, int)){}

    PlayerJoinedGameEvent<public>:subscribable_event(tuple(player, int)) = subscribable_event(tuple(player, int)){}

    var NextPlayerNumber:int = 0
    
    OnBegin<override>()<suspends>:void =
        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)

    OnPlayerAdded(Player:player):void =
        PlayerJoinedGameEvent.Signal(Player, NextPlayerNumber)
        set NextPlayerNumber += 1

event_listener_device := class(creative_device):

    @editable
    Signaller:event_signaller_device = event_signaller_device{}

    OnBegin<override>()<suspends>:void =
        Cancelable := Signaller.PlayerJoinedGameEvent.Subscribe(OnPlayerJoinedGame)

        Sleep(60.0)
        Cancelable.Cancel()

    OnPlayerJoinedGame<private>(Player:player, Number:int):void =
        {}

Copy-paste each file above is always free.

Subscribable Event

Comments