Class: RMXEventsFromProxy

Inherits:
Object
  • Object
show all
Defined in:
lib/motion/RMXEventsFromProxy.rb

Overview

Proxy class used to hold the actual handlers and contexts of handlers. When the real class deallocates, all handlers are removed.

Constant Summary collapse

QUEUE = 
Dispatch::Queue.new("RMXEventsFromProxy")

Instance Method Summary collapse

Constructor Details

#initialize ⇒ RMXEventsFromProxy

Returns a new instance of RMXEventsFromProxy.



7
8
9
 
# File 'lib/motion/RMXEventsFromProxy.rb', line 7

def initialize
  @events = {}
end

Instance Method Details

#now_and_on(event, opts = {}, &block) ⇒ Object 



36
37
38
39
 
# File 'lib/motion/RMXEventsFromProxy.rb', line 36

def now_and_on(event, opts={}, &block)
  RMX.block_on_main_q(block)
  on(event, opts, &block)
end

#off(event = nil, execution_block = nil) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/motion/RMXEventsFromProxy.rb', line 41

def off(event=nil, execution_block=nil)
  QUEUE.sync do
    if event.is_a?(String) || event.is_a?(Symbol)
      event = event.to_s
      if execution_block
        if events = @events[event]
          deleted = events.delete(execution_block)
          if RMX::DEBUG_EVENTS
            p "remove the one block for the event", "EVENT:", event, "deleted:", deleted
          end
        end
      else
        deleted = @events.delete(event)
        if RMX::DEBUG_EVENTS
          p "remove all blocks for the event", "EVENT:", event, "deleted:", deleted
        end
      end
    else
      @events.clear
      if RMX::DEBUG_EVENTS
        p "remove all blocks for all events"
      end
    end
  end
  nil
end

#on(event, opts = {}, &block) ⇒ Object

def rmx_dealloc

off
super

end



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/motion/RMXEventsFromProxy.rb', line 16

def on(event, opts={}, &block)
  block ||= proc {}
  event = event.to_s
  execution_block = RMXExecutionBlock.new
  execution_block.strong = opts.delete(:strong)
  execution_block.limit = opts.delete(:limit)
  execution_block.queue = opts.delete(:queue)
  execution_block.meta = opts
  execution_block.block = block
  off_block = RMXExecutionBlock.new
  off_block.block = proc do
    off(event, execution_block)
  end
  QUEUE.sync do
    @events[event] ||= []
    @events[event] << execution_block
  end
  off_block
end

#trigger(event, *values) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/motion/RMXEventsFromProxy.rb', line 68

def trigger(event, *values)
  QUEUE.async do
    # if RMX::DEBUG_EVENTS
    #   p "TRIGGER:", event, values, "@events", @events
    # end
    event = event.to_s
    _execution_blocks = @events[event]
    next unless _execution_blocks
    execution_blocks = _execution_blocks.dup
    while execution_blocks.size > 0
      execution_block = execution_blocks.shift
      exclusive = execution_block.meta[:exclusive]
      if exclusive
        _exclusive = exclusive.dup
        while _exclusive.size > 0
          exclude = _exclusive.shift.to_s
          deleted = @events.delete(exclude)
          if RMX::DEBUG_EVENTS
            p "REMOVING DUE TO EXCLUSIVE:", exclude, "FOR EVENT:", event, "deleted:", deleted
          end
        end
      end
      execution_block.call(*values)
      if execution_block.dead
        deleted = _execution_blocks.delete(execution_block)
        if RMX::DEBUG_EVENTS
          p "REMOVING DUE TO DEAD:", "FOR EVENT:", event, "deleted:", deleted
        end
      end
    end
  end
  nil
end