class Timers::Group

A collection of timers which may fire at different times

Attributes

events[R]

Scheduled events:

paused_timers[R]

Paused timers:

timers[R]

Active timers:

Public Class Methods

new() click to toggle source
# File lib/timers/group.rb, line 23
def initialize
        @events = Events.new

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

        @interval = Interval.new
        @interval.start
end

Public Instance Methods

after(interval, &block) click to toggle source

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.

# File lib/timers/group.rb, line 44
def after(interval, &block)
        Timer.new(self, interval, false, &block)
end
cancel() click to toggle source

Cancel all timers.

# File lib/timers/group.rb, line 123
def cancel
        @timers.dup.each(&:cancel)
end
continue()
Alias for: resume
current_offset() click to toggle source

The group's current time.

# File lib/timers/group.rb, line 128
def current_offset
        @interval.to_f
end
delay(seconds) click to toggle source

Delay all timers.

# File lib/timers/group.rb, line 116
def delay(seconds)
        @timers.each do |timer|
                timer.delay(seconds)
        end
end
every(interval, recur = true, &block) click to toggle source

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.

# File lib/timers/group.rb, line 57
def every(interval, recur = true, &block)
        Timer.new(self, interval, recur, &block)
end
fire(offset = current_offset) click to toggle source

Fire all timers that are ready.

# File lib/timers/group.rb, line 99
def fire(offset = current_offset)
        @events.fire(offset)
end
now_and_after(interval) { || ... } click to toggle source

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.

# File lib/timers/group.rb, line 50
def now_and_after(interval, &block)
        yield
        after(interval, &block)
end
now_and_every(interval, recur = true) { || ... } click to toggle source

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.

# File lib/timers/group.rb, line 63
def now_and_every(interval, recur = true, &block)
        yield
        every(interval, recur, &block)
end
pause() click to toggle source

Pause all timers.

# File lib/timers/group.rb, line 104
def pause
        @timers.dup.each(&:pause)
end
resume() click to toggle source

Resume all timers.

# File lib/timers/group.rb, line 109
def resume
        @paused_timers.dup.each(&:resume)
end
Also aliased as: continue
wait() { |wait_interval| ... } click to toggle source

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).

# File lib/timers/group.rb, line 71
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) click to toggle source

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

# File lib/timers/group.rb, line 93
def wait_interval(offset = current_offset)
        handle = @events.first
        handle.time - Float(offset) if handle
end