Events: Difference between revisions

 

The event interface:

procedure Signal;

procedure Reset;

private

Fired : Boolean := False;

The event implementation:

procedure Signal is

begin

null;

end Wait;

With the event defined above:

 

procedure Test_Events is

Put_Line ("Signal X");

X.Signal;

Sample output:

<pre>

 

=={{header|AutoHotkey}}==

Return

 

F2:: ; external event: fire on F2 key press

TrayTip, external, f2 key pressed

 

=={{header|BBC BASIC}}==

===API===

This uses a Windows event object:

WAIT_TIMEOUT = 258

DEF PROCelapsed

SYS "SetEvent", hEvent%

===Native===

This uses a simple variable as a semaphore:

Event% = FALSE

DEF PROCelapsed

Event% = TRUE

 

=={{header|C}}==

Using pipe to communicate to <code>fork</code>ed child. Since child will be blocking trying to read the other end of the pipe, this can be used for synchronization.

#include <unistd.h>

 

}

return 0;

 

=={{header|C sharp|C#}}==

using System.Timers;

 

((Timer)sender).Stop();

}

Sample output:

<pre>10-11-2010 18:35:11

=={{header|Clojure}}==

{{trans|Go}}

(:require [clojure.core.async :refer [>! <! >!! <!! go chan]])

(:require [clj-time.core :as time])

; Invoke -main function

(-main)

{{Output}}

<pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

end;

Readln;

Sample output:

<pre>

 

=={{header|E}}==

def [var fired, var firer] := Ref.promise()

return event

The event object has this behavior: the return value of <code>.wait()</code> will be resolved after the time of the earliest <code>.signal()</code> for which there is no intervening <code>.reset()</code>.

 

{

})

println("[1] Waiting 1 second...")

 

=={{header|Elixir}}==

{{trans|Erlang}}

def log(msg) do

time = Time.utc_now |> to_string |> String.slice(0..7)

end

 

 

{{out}}

=={{header|Erlang}}==

Events can be implemented by using the selective receive expression and erlang's built in message passing. Here task waits for the message 'go' before it will continue.

-module(events).

-compile(export_all).

P ! go,

timer:sleep(100).

'''Output:'''

66> events:main().

0: 0:57 => Program start

0: 0:58 => Task resumed

ok

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

open System.Timers

 

timer.Start()

ignore <| Console.ReadLine()

 

 

=={{header|FreeBASIC}}==

{{trans|Gambas}}

Sub Timer1_Timer()

Print Time

End Sub

{{out}}

<pre>

</pre>

 

 

=={{header|Gambas}}==

 

Print Str(Time(Now))

 

Output:

<pre>

=={{header|Go}}==

A Go channel can represent an manual-reset event, as described by the task. The two states of signaled and reset correspond to the presence or absence of a value on the channel. The program signals by sending a value on the channel. The event is reset when the waiting task explicitly executes the channel receive operation, <-event.

 

import (

event <- 0

time.Sleep(100 * time.Millisecond)

{{out}}

<pre>

 

=={{header|Haskell}}==

import Control.Concurrent.SampleVar

 

signalEvent (Event sv) = writeSampleVar sv ()

resetEvent (Event sv) = emptySampleVar sv

forkIO (waitTask e)

putStrLn "[1] Waiting 1 second..."

waitTask e = do putStrLn "[2] Waiting for event..."

waitEvent e

Note: Because there is no serialization of the text output, there is a chance that it will appear interleaved.

 

The following only works in Unicon. The example illustrates the multiple tasks can

receive the same event:

 

procedure main()

signal(event.cond,0)

every wait(t1|t2)

 

Sample run:

=={{header|JavaScript}}==

An example using the [[wp:Yahoo!_UI_Library|YUI]] library:

// add a custom event:

Y.on('my:event', function () {

Y.fire('my:event');

}, 1000);

An example simulating [[wp:Document_Object_Model|DOM]] events:

// add a click event handler to a DOM node with id "button":

Y.one("#button").on("click", function (e) {

Y.one("#button").simulate("click");

}, 1000);

 

=={{header|Julia}}==

between two child threads.

 

function dolongcomputation(cond)

det(rand(4000, 4000))

sleep(5)

println("Done sleeping.")

{{output}}<pre>

Starting task, sleeping...

Paste in the REPL:

 

(defun log (msg)

(let ((`#(,h ,m ,s) (erlang:time)))

(! pid 'go)

(timer:sleep 100))))

 

Usage:

 

To catch an event, a corresponding event handler - a function with a predefined name - has to be definined in the code. Examples for such event handlers are:

on closeWindow

...

on mouseDown

...

Also "Sprites" (visual elements) receive events by setting up such event handlers in scripts attached to them. Both predefined and custom events can be sent programmatically to sprites, e.g. using:

sendSprite(1, #mouseDown)

 

 

-- send custom event #fooBar to all existing sprites

 

Using a binary plugin ("Xtra"), in Windows also lower level window messages can be both sent and received:

{{libheader|Msg Xtra}}

 

-- send message WM_LBUTTONDOWN to a specific window identified by HWND hwnd

WM_COPYDATA = 74

WM_MOUSEWHEEL = 522

 

Mathematica supports events from timers (via Pause[]), task schedule descriptors. This will print a message after 4 seconds, then terminate the program.

 

=={{header|Nim}}==

{{trans|C}}

 

var p: array[2, cint]

discard close p[1]

discard p[0].read(addr p[1], 1)

 

===Stdlib Semaphore===

This version using locks module for signaling the condition.

 

from os import sleep

import times

deinitLock lock

 

 

Compile and run: <pre>nim c -r --threads:on events_cond.nim</pre>

An event is often implemented with a control channel. A task is waiting for an object on the channel. When the event occurs, another task sends an object on this channel.

 

| ch |

Channel new ->ch

#[ ch receive "Ok, event is signaled !" println ] &

System sleep(1000)

 

An emitter is a general implementation for handling events : an emitter waits for events emitted and launches listeners that are waiting for those events.

 

: anEvent2

$myEvent e emit

]

 

=={{header|Oz}}==

{{trans|Haskell}}

Events can be implemented as mutable references to dataflow variables:

fun {NewEvent}

{NewCell _}

{Delay 1000}

{System.showInfo "[1] Signaling event."}

However, this code is quite unidiomatic. If we need to wait for an event just once (like in this example), we can simply use a dataflow variable, i.e. an event that cannot be reset:

E

in

{Delay 1000}

{System.showInfo "[1] Signaling event."}

If we want to synchronize two threads repeatedly and exchange data, it is natural to use ports and streams. Streams are just lists with an unbound tail. A port is basically a pointer to the tail of a list, i.e. it keeps track of where the next event can be written to:

MyPort

in

{System.showInfo "[1] Signaling event."}

{Port.send MyPort unit}

It is important to limit the scope of a stream as much as possible to ensure that the already read part of the stream is garbage-collected.

 

This is an example of using the [http://search.cpan.org/perldoc?AnyEvent AnyEvent] module.

The result is this: it prints "Hello world!" after one second, then after another second prints "Hi!" four times every quarter of a second and then immediately prints "Bye!" and quits:

 

# a new condition with a callback:

 

# wait for the $quit condition to be ready:

This is the same using AnyEvent [http://search.cpan.org/perldoc?AE simplified API]:

 

my $quit = AE::cv sub { warn "Bye!\n" };

};

 

 

=={{header|Phix}}==

in main() acts as signalling an event, and the one in echo() from whichever goes first acts to signal

that the other can/should resume.

{{out}}

Typically the first thread to attempt enter_cs() is released first, but there is

</pre>

External events such as timers and user input are handled in pGUI, eg

 

=={{header|PicoLisp}}==

This will print a message after one second, then terminate the program after

another four seconds:

(prinl "Exit in 4 seconds")

 

=={{header|PowerShell}}==

$timer = New-Object -TypeName System.Timers.Timer -Property @{Enabled=$true; Interval=1000; AutoReset=$true}

 

$global:counter = 0

& $job.Module {$global:counter}

{{Out}}

<pre>

 

=={{header|PureBasic}}==

ButtonGadget (1, 10, 10, 35, 20, "Quit")

 

EndIf

 

=={{header|Python}}==

 

import threading

import time

print("Main: Done")

t.join()

 

=={{header|Racket}}==

the task (since it's a useless value):

 

#lang racket

 

 

(void (sync task)) ; wait for the task to be done before exiting

 

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Go}}

my $event = Channel.new;

 

note now, " program signaling event";

$event.send(0);

{{out}}

<pre>Instant:1403880984.089974 program start

Although REXX can be event driven, most events would probably have to be actively checked to see if the event occurs.

<br>Here is a &nbsp; ''time-driven'' &nbsp; example of events happening, based on specific timer ticks.

parse arg timeEvent /*allow the "event" to be specified. */

 

event?: do forever /*determine if an event has occurred. */

end /*forever*/

 

say 'Control should never get here!' /*This is a logic can─never─happen ! */

/*──────────────────────────────────────────────────────────────────────────────────────*/

happening: say 'an event occurred at' time()", the event is:" theEvent

nop /*replace NOP with the "process" code.*/

<pre>

an event occurred at 16:13:29, the event is: 9

Rust ensures memory safety at compile-time without needing a garbage collector or runtime. There are several concurrency primitives in it's standard library.

 

use std::{sync::mpsc, thread, time::Duration};

 

Ok(())

}

 

=={{header|Tcl}}==

Tcl has been event-driven since 7.5, but only supported channel and timer events (plus variable traces, which can be used to create event-like entitites). With the addition of coroutines, it becomes much simpler to create general events:

{{works with|Tcl|8.6}}

proc pause ms {

after $ms [info coroutine];yield

X signal

}

Output:

<pre>waiting for event

received event</pre>

Of course, the classic way of writing this is much shorter, but intermingles the tasks:

puts "waiting for event"

vwait X

 

=={{header|Wren}}==

 

The tasks to be executed are added to a list by the Scheduler class. The Timer.sleep method suspends the current fiber and signals the scheduler (by calling a private method) to execute the tasks one by one in their own fibers - in Wren only one fiber can execute at a time. The task results are then available to the main fiber on its resumption after Timer.sleep has completed.

import "timer" for Timer

 

System.print(a) // still 3

Timer.sleep(3000) // wait 3 seconds

 

{{out}}

10

</pre>

 

=={{header|zkl}}==

zkl provides an Atomics library for things like this. Events are async, waiting for an event doesn't poll.

// create thread waiting for event

fcn(event){event.wait(); println(vm," ping!")}.launch(event);

Atomic.sleep(1);

event.set();

{{out}}

<pre>