Class: Timers::Group

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Enumerable
Defined in:
lib/timers/group.rb

Overview

A collection of timers which may fire at different times

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Group

Returns a new instance of Group.



18
19
20
21
22
23
24
25
26
 
# File 'lib/timers/group.rb', line 18

def initialize
  @events = Events.new

  @timers = Set.new
  @paused_timers = Set.new

  @interval = Hitimes::Interval.new
  @interval.start
end

Instance Attribute Details

#events ⇒ Object (readonly)

Scheduled events:



29
30
31
 
# File 'lib/timers/group.rb', line 29

def events
  @events
end

#paused_timers ⇒ Object (readonly)

Paused timers:



35
36
37
 
# File 'lib/timers/group.rb', line 35

def paused_timers
  @paused_timers
end

#timers ⇒ Object (readonly)

Active timers:



32
33
34
 
# File 'lib/timers/group.rb', line 32

def timers
  @timers
end

Instance Method Details

#after(interval, &block) ⇒ Object

Call the given block after the given interval. The first argument will be the time at which the group was asked to fire timers for.



39
40
41
 
# File 'lib/timers/group.rb', line 39

def after(interval, &block)
  Timer.new(self, interval, false, &block)
end

#cancel ⇒ Object

Cancel all timers.



118
119
120
 
# File 'lib/timers/group.rb', line 118

def cancel
  @timers.dup.each(&:cancel)
end

#current_offset ⇒ Object

The group’s current time.



123
124
125
 
# File 'lib/timers/group.rb', line 123

def current_offset
  @interval.to_f
end

#delay(seconds) ⇒ Object

Delay all timers.



111
112
113
114
115
 
# File 'lib/timers/group.rb', line 111

def delay(seconds)
  @timers.each do |timer|
    timer.delay(seconds)
  end
end

#every(interval, recur = true, &block) ⇒ Object

Call the given block periodically at the given interval. The first argument will be the time at which the group was asked to fire timers for.



52
53
54
 
# File 'lib/timers/group.rb', line 52

def every(interval, recur = true, &block)
  Timer.new(self, interval, recur, &block)
end

#fire(offset = current_offset) ⇒ Object

Fire all timers that are ready.



94
95
96
 
# File 'lib/timers/group.rb', line 94

def fire(offset = current_offset)
  @events.fire(offset)
end

#now_and_after(interval, &block) ⇒ Object

Call the given block immediately, and then after the given interval. The first argument will be the time at which the group was asked to fire timers for.



45
46
47
48
 
# File 'lib/timers/group.rb', line 45

def now_and_after(interval, &block)
  yield
  after(interval, &block)
end

#now_and_every(interval, recur = true, &block) ⇒ Object

Call the given block immediately, and then periodically at the given interval. The first argument will be the time at which the group was asked to fire timers for.



58
59
60
61
 
# File 'lib/timers/group.rb', line 58

def now_and_every(interval, recur = true, &block)
  yield
  every(interval, recur, &block)
end

#pause ⇒ Object

Pause all timers.



99
100
101
 
# File 'lib/timers/group.rb', line 99

def pause
  @timers.dup.each(&:pause)
end

#resume ⇒ Object Also known as: continue

Resume all timers.



104
105
106
 
# File 'lib/timers/group.rb', line 104

def resume
  @paused_timers.dup.each(&:resume)
end

#wait ⇒ Object

Wait for the next timer and fire it. Can take a block, which should behave like sleep(n), except that n may be nil (sleep forever) or a negative number (fire immediately after return).



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/timers/group.rb', line 66

def wait
  if block_given?
    yield wait_interval

    while (interval = wait_interval) && interval > 0
      yield interval
    end
  else
    while (interval = wait_interval) && interval > 0
      # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
      sleep interval
    end
  end

  fire
end

#wait_interval(offset = current_offset) ⇒ Object

Interval to wait until when the next timer will fire.

  • nil: no timers

  • -ve: timers expired already

  • 0: timers ready to fire

  • +ve: timers waiting to fire



88
89
90
91
 
# File 'lib/timers/group.rb', line 88

def wait_interval(offset = current_offset)
  handle = @events.first
  handle.time - Float(offset) if handle
end