# limitations under the License.
class Node
- redef meth to_s: String
+ redef fun to_s: String
do
return _name
end
- attr _name: String = "noname"
+ var name: String = "noname"
end
class WakeUpNode
-special Node
- meth wake_up is abstract
+ super Node
+ fun wake_up is abstract
# Wake up the node
- meth wake_up_in(d: Int)
+ fun wake_up_in(d: Int)
# Ask to be weaked up in `d' time units
do
_scheduler.add_event(self, d)
end
- attr _scheduler: Scheduler
+ var scheduler: Scheduler is noinit
end
class NodeSource
-special Node
- attr _nexts: nullable ArraySet[NodeSink] = null
- meth attach(n: NodeSink)
+ super Node
+ var nexts: nullable ArraySet[NodeSink] = null
+ fun attach(n: NodeSink)
# Add the sink `n' the the connected nodes
# Do nothing if `n' is already connected
do
- assert n != null
# Create the collection if needed
if _nexts == null then
_nexts = new ArraySet[NodeSink]
_nexts.add(n)
end
- meth detach(n: NodeSink)
+ fun detach(n: NodeSink)
# Remove the sink `n' from the connected nodes
# Do nothing if `n' is not connected
do
- assert n != null
_nexts.remove(n)
end
- protected meth send
+ protected fun send
# Notify the sinks by calling the recieve(1) method of each sink
do
if _nexts == null then
end
class NodeSink
-special Node
- meth recieve(n: NodeSource) is abstract
+ super Node
+ fun recieve(n: NodeSource) is abstract
# the `n' has emeted a signal
end
#
class Scheduler
- attr _time_list: Array[Couple[Int, WakeUpNode]] = new Array[Couple[Int, WakeUpNode]]
- attr _time: Int = 0 # What time is it ?
- meth add_event(n: WakeUpNode, d: Int)
+ var time_list: Array[Couple[Int, WakeUpNode]] = new Array[Couple[Int, WakeUpNode]]
+ var time: Int = 0 # What time is it ?
+ fun add_event(n: WakeUpNode, d: Int)
# The node `n' whant to be weaked up in `d' time units
do
var entry = new Couple[Int, WakeUpNode](d+_time, n)
_time_list.add(entry)
end
- meth next_event: nullable WakeUpNode
+ fun next_event: nullable WakeUpNode
# Get the
do
if _time_list.is_empty then
return entry.second
end
- meth run_for(time_limit: Int)
+ fun run_for(time_limit: Int)
do
- while true do
+ loop
var node = next_event
if _time > time_limit then
print("Time limit.")
#
class BeepSource
-special NodeSource
-special WakeUpNode
- redef meth wake_up
+ super NodeSource
+ super WakeUpNode
+ redef fun wake_up
do
send
wake_up_in(_delay)
end
- attr _delay: Int
- meth start
+ var delay: Int
+ fun start
do
wake_up_in(_delay)
end
end
class CountSink
-special NodeSink
- readable attr _count: Int = 0
- redef meth recieve(n: NodeSource)
+ super NodeSink
+ var count: Int = 0
+ redef fun recieve(n: NodeSource)
do
- _count = _count + 1
+ count = count + 1
end
end
class SimpleCountSink
-special CountSink
+ super CountSink
init(name: String)
do
end
class NodeAlternate
-special NodeSink
-special NodeSource
- attr _last: nullable NodeSource
- redef meth recieve(n: NodeSource)
+ super NodeSink
+ super NodeSource
+ var last: nullable NodeSource
+ redef fun recieve(n: NodeSource)
do
if n != _last then
_last = n
end
class NodeEat
-special CountSink
-special NodeSource
- attr _limit: Int
- redef meth recieve(n: NodeSource)
+ super CountSink
+ super NodeSource
+ var limit: Int
+ redef fun recieve(n: NodeSource)
do
- var c = _count + 1
+ var c = count + 1
if c >= _limit then
- _count = 0
+ count = 0
send
else
- _count = c
+ count = c
end
end
end
class NodeDelay
-special NodeSource
-special NodeSink
-special WakeUpNode
- attr _delay: Int
- redef meth recieve(n: NodeSource)
+ super NodeSource
+ super NodeSink
+ super WakeUpNode
+ var delay: Int
+ redef fun recieve(n: NodeSource)
do
wake_up_in(_delay)
end
- redef meth wake_up
+ redef fun wake_up
do
send
end
b1.start
b2.start
-var nb = 100000
+var nb = 10
if not args.is_empty then
nb = args.first.to_i
end
-s.run_for(nb)
+s.run_for(1.lshift(nb))
print(c1.count)