Class: Timers::Group

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Group

Returns a new instance of Group.



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

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:



27
28
29
 
# File 'lib/timers/group.rb', line 27

def events
  @events
end

#paused_timers ⇒ Object (readonly)

Paused timers:



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

def paused_timers
  @paused_timers
end

#timers ⇒ Object (readonly)

Active timers:



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

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.



37
38
39
 
# File 'lib/timers/group.rb', line 37

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

#cancel ⇒ Object

Cancel all timers.



107
108
109
110
111
 
# File 'lib/timers/group.rb', line 107

def cancel
  @timers.dup.each do |timer|
    timer.cancel
  end
end

#current_offset ⇒ Object

The group’s current time.



114
115
116
 
# File 'lib/timers/group.rb', line 114

def current_offset
  @interval.to_f
end

#delay(seconds) ⇒ Object

Delay all timers.



100
101
102
103
104
 
# File 'lib/timers/group.rb', line 100

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.



43
44
45
 
# File 'lib/timers/group.rb', line 43

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

#fire(offset = self.current_offset) ⇒ Object

Fire all timers that are ready.



79
80
81
 
# File 'lib/timers/group.rb', line 79

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

#pause ⇒ Object

Pause all timers.



84
85
86
87
88
 
# File 'lib/timers/group.rb', line 84

def pause
  @timers.dup.each do |timer|
    timer.pause
  end
end

#resume ⇒ Object Also known as: continue

Resume all timers.



91
92
93
94
95
 
# File 'lib/timers/group.rb', line 91

def resume
  @paused_timers.dup.each do |timer|
    timer.resume
  end
end

#wait(&block) ⇒ 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).



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/timers/group.rb', line 50

def wait(&block)
  if block_given?
    yield wait_interval
    
    while interval = wait_interval and interval > 0
      yield interval
    end
  else
    while interval = wait_interval and 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 = self.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



72
73
74
75
76
 
# File 'lib/timers/group.rb', line 72

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