fsevent 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 190a71cc39238eaa13406a607bd3156a708b9327
-  data.tar.gz: 312958f08630a7f81721fa2738b3a5375537bdac
+  metadata.gz: a29fe94eaba408b87373eb438cb5586bc0d97906
+  data.tar.gz: 837f02c21999e8b41e86e22066d0f198111cbb0c
 SHA512:
-  metadata.gz: ee4a193a6b9bae8d14f19be365ff123578495774bb2dcff9a27afac8b83e8a87ad55dd63aaab6f7ac76f7749a28fe704d2d34574f59c6baf5f8491a58c9917b9
-  data.tar.gz: ee1aa94816594f090d13ea360e8ca2095be7829d1655f6030b9a54b68e4d1c4874007f5908f7200dfac2ef3877b71c705d203d645b00d7e5c0d305b6a9b4c1a0
+  metadata.gz: 2e163903a427283fa54b05c675a5aa806f872c750e8da21f3e084061efdc3457e552cc5eeda138cef43f2671c04a703cec9b6143e13106c4ccfdc6d9cbfd7981
+  data.tar.gz: 902f766db3e5148e76c60bfd25f245bbd738b423a6d15a89545ff98c19a650ee05fdb1479ca6f59ed966a9276682e1189e13c25dfbd3b0f4377852d6525e5300

data/README.md

@@ -2,10 +2,21 @@
 
 fail safe event driven framework
 
+# install
+
+```
+gem install fsevent
+```
+
 # author
 
 Tanaka Akira
 
+# links
+
+- https://github.com/fsevent/fsevent
+- http://rubygems.org/gems/fsevent
+
 # license
 GPLv3 or later
 

data/fsevent.gemspec

@@ -1,11 +1,13 @@
 Gem::Specification.new do |s|
   s.name = 'fsevent'
-  s.version = '0.1'
-  s.date = '2013-06-23'
+  s.version = '0.2'
+  s.date = '2013-06-30'
   s.author = 'Tanaka Akira'
   s.email = 'tanaka-akira@aist.go.jp'
   s.license = 'GPL-3.0+'
   s.required_ruby_version = '>= 1.9.2'
+  s.add_runtime_dependency 'depq', '~> 0.6'
+  s.add_development_dependency 'test-unit', '~> 2.5'
   s.files = %w[
     .gitignore
     LICENSE
@@ -13,6 +15,7 @@ Gem::Specification.new do |s|
     fsevent.gemspec
     lib/fsevent.rb
     lib/fsevent/abstractdevice.rb
+    lib/fsevent/debugdumper.rb
     lib/fsevent/failsafedevice.rb
     lib/fsevent/framework.rb
     lib/fsevent/periodicschedule.rb
@@ -21,6 +24,7 @@ Gem::Specification.new do |s|
     lib/fsevent/schedulemerger.rb
     lib/fsevent/simpledevice.rb
     lib/fsevent/util.rb
+    lib/fsevent/watchset.rb
     sample/repeat.rb
     sample/repeat2.rb
   ]

data/lib/fsevent.rb

@@ -17,13 +17,18 @@
 
 require 'rbconfig'
 require 'depq'
+require 'pp'
 
 class FSEvent
+  class FSEventError < StandardError
+  end
 end
 
 require 'fsevent/util'
+require 'fsevent/watchset'
 require 'fsevent/framework'
 require 'fsevent/abstractdevice'
+require 'fsevent/debugdumper'
 require 'fsevent/simpledevice'
 require 'fsevent/processdevice'
 require 'fsevent/processdevicec'

data/lib/fsevent/abstractdevice.rb

@@ -26,13 +26,19 @@ class FSEvent::AbstractDevice
   attr_reader :name, :schedule
   attr_writer :framework
 
+  def inspect
+    "\#<#{self.class}: #{@name}>"
+  end
+
   # Called from the framework when this device is registered.
   def registered
     # child process calls:
-    # * @framework.add_watch
-    # * @framework.define_status
-    # * @framework.status_changed # possible but needless
-    # * @framework.set_elapsed_time
+    # * add_watch
+    # * del_watch # possible but needless
+    # * define_status
+    # * modify_status # possible but needless
+    # * undefine_status # possible but needless
+    # * set_elapsed_time
   end
 
   # Called from the framework when this device is unregistered.
@@ -40,25 +46,39 @@ class FSEvent::AbstractDevice
   end
 
   # Called from the framework
-  def run(watched_status_change)
+  def run(watched_status, changed_status)
     raise NotImplementedError
     # child process calls:
-    # * @framework.add_watch # possible but should be rare
-    # * @framework.define_status # possible but should be rare
-    # * @framework.status_changed
-    # * @framework.set_elapsed_time
+    # * add_watch # possible but should be rare
+    # * del_watch
+    # * define_status # possible but should be rare
+    # * modify_status
+    # * undefine_status
+    # * set_elapsed_time
+  end
+
+  def add_watch(watchee_device_name_pat, status_name_pat, reaction = :immediate)
+    @framework.add_watch(watchee_device_name_pat, status_name_pat, reaction)
   end
 
-  def add_watch(watchee_device_name, status_name, reaction = :immediate)
-    @framework.add_watch(watchee_device_name, status_name, reaction)
+  def del_watch(watchee_device_name_pat, status_name_pat)
+    @framework.del_watch(watchee_device_name_pat, status_name_pat)
   end
 
   def define_status(status_name, value)
     @framework.define_status(status_name, value)
   end
 
-  def status_changed(status_name, value)
-    @framework.status_changed(status_name, value)
+  def modify_status(status_name, value)
+    @framework.modify_status(status_name, value)
+  end
+
+  def undefine_status(status_name)
+    @framework.undefine_status(status_name)
+  end
+
+  def register_device(device)
+    @framework.register_device(device)
   end
 
   def unregister_device(device_name)

data/lib/fsevent/debugdumper.rb

@@ -0,0 +1,33 @@
+# debugdumper.rb --- device for debug dump
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Abstract class for devices
+#
+class FSEvent::DebugDumper < FSEvent::AbstractDevice
+  def initialize(device_name="debugdumper")
+    super
+  end
+
+  def registered
+    add_watch("*", "*")
+  end
+
+  def run(watched_status, changed_status)
+    #pp watched_status
+    pp changed_status
+  end
+end

data/lib/fsevent/failsafedevice.rb

@@ -18,9 +18,9 @@
 class FSEvent::FailSafeDevice < FSEvent::AbstractDevice
   def initialize(device_name, initial_status, *watchee_device_names)
     super device_name
-    raise "One devices required at least" if watchee_device_names.empty?
+    raise ArgumentError, "One devices required at least" if watchee_device_names.empty?
     @current_status = {} # status_name -> value
-    @current_status_list = {} # status_name -> watchee_device_name status_name -> value
+    @current_status_list = {} # status_name -> watchee_device_name -> value
     @status_merger = {}
     initial_status.each {|k, v, merger|
       @current_status[k] = v
@@ -61,10 +61,12 @@ class FSEvent::FailSafeDevice < FSEvent::AbstractDevice
     }
   end
 
-  def run(watched_status_change)
+  def run(watched_status, changed_status)
     updated = {}
-    watched_status_change.each {|watchee_device_name, h|
-      h.each {|status_name, value|
+    changed_status.each {|watchee_device_name, h|
+      h.each {|status_name, time|
+        next if /\A_/ =~ status_name
+        value = watched_status[watchee_device_name][status_name]
         unless updated.has_key? status_name
           updated[status_name] = @current_status_list[status_name]
         end
@@ -78,7 +80,7 @@ class FSEvent::FailSafeDevice < FSEvent::AbstractDevice
       new_val = merger.call(cur_val, *values)
       if cur_val != new_val
         @current_status[status_name] = new_val
-        status_changed status_name, new_val
+        modify_status status_name, new_val
       end
     }
   end

data/lib/fsevent/framework.rb

@@ -20,279 +20,459 @@ class FSEvent
 
   def initialize(initial_time=Time.now)
     @current_time = initial_time
+    @current_count = 0
 
     @devices = {} # device_name -> device
+    @device_last_run_count = {} # device_name -> count
 
-    @status = {} # device_name -> status_name -> value
+    # special status:
+    #   _fsevent : _device_registered_DEVICE_NAME       => time
+    #   _fsevent : _device_unregistered_DEVICE_NAME     => time
+    #   DEVICE_NAME : _status_defined_STATUS_NAME       => time
+    #   DEVICE_NAME : _status_undefined_STATUS_NAME     => time
+    #
+    @status_value = { "_fsevent" => {} } # device_name -> status_name -> value
+    @status_time = { "_fsevent" => {} } # device_name -> status_name -> time
+    @status_count = { "_fsevent" => {} } # device_name -> status_name -> count
 
-    # valid values of reaction: :immediate, :immediate_only_at_beginning, :schedule
-    @watches = nested_hash(3) # watchee_device_name -> status_name -> watcher_device_name -> reaction
-    @watch_patterns = [] # [watchee_device_name_pat, status_name_pat, watcher_device_name, reaction]
-    @watched_status_change = nested_hash(3) # watcher_device_name -> watchee_device_name -> status_name -> value
+    @watchset = FSEvent::WatchSet.new
+
+    @clock_proc = nil
 
     @q = Depq.new
     @schedule_locator = {} # device_name -> locator
   end
   attr_reader :current_time
+  attr_accessor :clock_proc
 
-  def register_device(device, register_time=@current_time)
+  def register_device(device)
     device_name = device.name
-    value = [:register, device_name, device]
-    @schedule_locator[device_name] = @q.insert value, register_time
+    if !valid_device_name_for_write?(device_name)
+      raise ArgumentError, "invalid device name: #{device_name.inspect}"
+    end
+    if !Thread.current[:fsevent_buffer]
+      value = [:register_start, device_name, device]
+      @schedule_locator[device_name] = @q.insert value, @current_time
+    else
+      value = [:register_device, device_name, device]
+      Thread.current[:fsevent_buffer] << value
+    end
   end
 
   def start
     until @q.empty?
       loc = @q.delete_min_locator
       event_type, *args = loc.value
+      @clock_proc.call(@current_time, loc.priority) if @clock_proc && @current_time != loc.priority
       @current_time = loc.priority
+      @current_count += 1
       case event_type
-      when :register; at_register(loc, *args)
-      when :wakeup; at_wakeup(loc, *args)
-      when :sleep; at_sleep(loc, *args)
+      when :register_start; at_register_start(loc, *args)
+      when :register_end; at_register_end(loc, *args)
+      when :run_start; at_run_start(loc, *args)
+      when :run_end; at_run_end(loc, *args)
       else
-        raise "unexpected event type: #{event_type}"
+        raise FSEvent::FSEventError, "unexpected event type: #{event_type}"
       end
     end
   end
 
   def wrap_device_action(&block)
-    Thread.current[:fsevent_device_watch_buffer] = device_watch_buffer = []
-    Thread.current[:fsevent_device_define_buffer] = device_define_buffer = []
-    Thread.current[:fsevent_device_changed_buffer] = device_changed_buffer = []
-    Thread.current[:fsevent_unregister_device_buffer] = unregister_device_buffer = []
+    Thread.current[:fsevent_buffer] = buffer = []
     Thread.current[:fsevent_device_elapsed_time] = nil
     t1 = Time.now
     yield
     t2 = Time.now
     elapsed = Thread.current[:fsevent_device_elapsed_time] || t2 - t1
-    return device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer, elapsed
+    return buffer, elapsed
   ensure
-    Thread.current[:fsevent_device_watch_buffer] = nil
-    Thread.current[:fsevent_device_define_buffer] = nil
-    Thread.current[:fsevent_device_changed_buffer] = nil
-    Thread.current[:fsevent_unregister_device_buffer] = nil
+    Thread.current[:fsevent_buffer] = nil
     Thread.current[:fsevent_device_elapsed_time] = nil
   end
   private :wrap_device_action
 
   # Called from a device.  (mainly from registered().)
-  def add_watch(watchee_device_name, status_name, reaction = :immediate)
-    Thread.current[:fsevent_device_watch_buffer] << [:add, watchee_device_name, status_name, reaction]
+  def add_watch(watchee_device_name_pat, status_name_pat, reaction = :immediate)
+    if !valid_device_name_pat_for_read?(watchee_device_name_pat)
+      raise ArgumentError, "invalid device name pattern: #{watchee_device_name_pat.inspect}"
+    end
+    if !valid_status_name_pat_for_read?(status_name_pat)
+      raise ArgumentError, "invalid status name pattern: #{status_name_pat.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:add_watch, watchee_device_name_pat, status_name_pat, reaction]
   end
 
   # Called from a device.  (mainly from registered().)
-  def del_watch(watchee_device_name, status_name)
-    Thread.current[:fsevent_device_watch_buffer] << [:del, watchee_device_name, status_name, nil]
+  def del_watch(watchee_device_name_pat, status_name_pat)
+    if !valid_device_name_pat_for_read?(watchee_device_name_pat)
+      raise ArgumentError, "invalid device name pattern: #{watchee_device_name_pat.inspect}"
+    end
+    if !valid_status_name_pat_for_read?(status_name_pat)
+      raise ArgumentError, "invalid status name pattern: #{status_name_pat.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:del_watch, watchee_device_name_pat, status_name_pat]
   end
 
   # Called from a device to define the status.
   def define_status(status_name, value)
-    Thread.current[:fsevent_device_define_buffer] << [status_name, value]
+    if !valid_status_name_for_write?(status_name)
+      raise ArgumentError, "invalid status name: #{status_name.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:define_status, status_name, value]
   end
 
   # Called from a device to notify the status.
-  def status_changed(status_name, value)
-    Thread.current[:fsevent_device_changed_buffer] << [status_name, value]
+  def modify_status(status_name, value)
+    if !valid_status_name_for_write?(status_name)
+      raise ArgumentError, "invalid status name: #{status_name.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:modify_status, status_name, value]
+  end
+
+  # Called from a device to define the status.
+  def undefine_status(status_name)
+    if !valid_status_name_for_write?(status_name)
+      raise ArgumentError, "invalid status name: #{status_name.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:undefine_status, status_name]
   end
 
   # Called from a device.
   def unregister_device(device_name)
-    Thread.current[:fsevent_unregister_device_buffer] << device_name
+    if !valid_device_name_for_write?(device_name)
+      raise ArgumentError, "invalid device name: #{device_name.inspect}"
+    end
+    Thread.current[:fsevent_buffer] << [:unregister_device, device_name]
   end
 
   # Called from a device to set the elapsed time.
   def set_elapsed_time(t)
-    raise "elapsed time must be positive: #{t}" if t <= 0
+    raise ArgumentError, "negative elapsed time given: #{t}" if t < 0
     Thread.current[:fsevent_device_elapsed_time] = t
   end
 
-  def at_register(loc, device_name, device)
+  def at_register_start(loc, device_name, device)
     if @devices.has_key? device_name
-      raise "Device already registered: #{device_name}"
+      raise ArgumentError, "Device already registered: #{device_name}"
     end
 
-    device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer, elapsed =
-      wrap_device_action {
+    buffer, elapsed = wrap_device_action {
         device.framework = self
         device.registered
     }
 
+    value = [:register_end, device_name, device, @current_count, buffer]
+    loc.update value, @current_time + elapsed
+    @q.insert_locator loc
+  end
+  private :at_register_start
+
+  def at_register_end(loc, device_name, device, register_start_count, buffer)
+    if @devices.has_key? device_name
+      raise ArgumentError, "Device already registered: #{device_name}"
+    end
+
     @devices[device_name] = device
-    @status[device_name] = {}
+    @device_last_run_count[device_name] = register_start_count
+    @status_value[device_name] = {}
+    @status_time[device_name] = {}
+    @status_count[device_name] = {}
 
-    value = [:sleep, device_name, device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer]
-    loc.update value, current_time + elapsed
-    @q.insert_locator loc
+    internal_update_status("_fsevent", @current_time, "_device_registered_#{device_name}", @current_time)
+
+    at_run_end(loc, device_name, register_start_count, buffer)
   end
-  private :at_register
+  private :at_register_end
 
-  def at_wakeup(loc, device_name)
+  def at_run_start(loc, device_name)
     time = loc.priority
     device = @devices[device_name]
 
-    watched_status_change = @watched_status_change.delete(device_name)
-    watched_status_change = nonempty_hash(watched_status_change, 2)
+    watched_status, changed_status = notifications(device_name, @device_last_run_count[device_name])
 
-    device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer, elapsed =
-      wrap_device_action { device.run(watched_status_change) }
+    buffer, elapsed = wrap_device_action { device.run(watched_status, changed_status) }
 
-    value = [:sleep, device_name, device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer]
+    value = [:run_end, device_name, @current_count, buffer]
     loc.update value, time + elapsed
     @q.insert_locator loc
   end
-  private :at_wakeup
-
-  def at_sleep(loc, device_name, device_watch_buffer, device_define_buffer, device_changed_buffer, unregister_device_buffer)
-    sleep_time = loc.priority
-    update_status(device_name, device_define_buffer, device_changed_buffer)
-    wakeup_immediate = update_watch(device_name, device_watch_buffer)
-    notify_status_change(device_name, sleep_time, device_define_buffer, device_changed_buffer)
-    wakeup_immediate ||= immediate_wakeup?(device_name)
-    setup_next_schedule(device_name, loc, sleep_time, wakeup_immediate)
-    unregister_device_internal(unregister_device_buffer)
+  private :at_run_start
+
+  def notifications(watcher_device_name, last_run_count)
+    watched_status = {}
+    changed_status = {}
+    @watchset.watcher_each(watcher_device_name) {|watchee_device_name_pat, status_name_pat, reaction|
+      matched_device_name_each(watchee_device_name_pat) {|watchee_device_name|
+        watched_status[watchee_device_name] ||= {}
+        changed_status[watchee_device_name] ||= {}
+        matched_status_name_each(watchee_device_name, status_name_pat) {|status_name|
+          if @status_value.has_key?(watchee_device_name) &&
+             @status_value[watchee_device_name].has_key?(status_name)
+            watched_status[watchee_device_name][status_name] = @status_value[watchee_device_name][status_name]
+          end
+          if @status_time.has_key?(watchee_device_name) &&
+             @status_time[watchee_device_name].has_key?(status_name) &&
+             last_run_count <= @status_count[watchee_device_name][status_name]
+            changed_status[watchee_device_name][status_name] = @status_time[watchee_device_name][status_name]
+          end
+        }
+      }
+    }
+    return watched_status, changed_status
   end
-  private :at_sleep
+  private :notifications
+
+  def at_run_end(loc, device_name, run_start_count, buffer)
+    @device_last_run_count[device_name] = run_start_count
+    run_end_time = loc.priority
 
-  def update_status(device_name, device_define_buffer, device_changed_buffer)
-    device_define_buffer.each {|status_name, value|
-      if @status[device_name].has_key? status_name
-        raise "device status already defined: #{device_name} #{status_name}"
+    wakeup_immediate = false
+    unregister_self = false
+
+    buffer.each {|tag, *rest|
+      case tag
+      when :define_status
+        internal_define_status(device_name, run_end_time, *rest)
+      when :modify_status
+        internal_modify_status(device_name, run_end_time, *rest)
+      when :undefine_status
+        internal_undefine_status(device_name, run_end_time, *rest)
+      when :add_watch
+        wakeup_immediate |= internal_add_watch(device_name, *rest)
+      when :del_watch
+        internal_del_watch(device_name, *rest)
+      when :register_device
+        internal_register_device(device_name, *rest)
+      when :unregister_device
+        unregister_self |= internal_unregister_device(device_name, *rest)
+      else
+        raise "unexpected tag: #{tag}"
       end
-      @status[device_name][status_name] = value
     }
-    device_changed_buffer.each {|status_name, value|
-      unless @status[device_name].has_key? status_name
-        raise "device status not defined: #{device_name} #{status_name}"
-      end
-      @status[device_name][status_name] = value
+
+    unless unregister_self
+      wakeup_immediate ||= immediate_wakeup_self?(device_name, run_start_count)
+      setup_next_schedule(device_name, loc, run_end_time, wakeup_immediate)
+    end
+  end
+  private :at_run_end
+
+  def internal_register_device(device_name, target_device_name, device)
+    value = [:register_start, target_device_name, device]
+    @schedule_locator[target_device_name] = @q.insert value, @current_time
+  end
+
+  def internal_define_status(device_name, run_end_time, status_name, value)
+    internal_define_status2(device_name, run_end_time, status_name, value)
+    internal_update_status(device_name, run_end_time, "_status_defined_#{status_name}", run_end_time)
+  end
+  private :internal_define_status
+
+  def internal_update_status(device_name, run_end_time, status_name, value)
+    if has_status?(device_name, status_name)
+      internal_modify_status2(device_name, run_end_time, status_name, value)
+    else
+      internal_define_status2(device_name, run_end_time, status_name, value)
+    end
+  end
+  private :internal_update_status
+
+  def has_status?(device_name, status_name)
+    @status_value.has_key?(device_name) && @status_value[device_name].has_key?(status_name)
+  end
+  private :has_status?
+
+  def internal_define_status2(device_name, run_end_time, status_name, value)
+    unless @status_value.has_key? device_name
+      raise ArgumentError, "device not defined: #{device_name}"
+    end
+    if @status_value[device_name].has_key? status_name
+      raise ArgumentError, "device status already defined: #{device_name} #{status_name}"
+    end
+    @status_value[device_name][status_name] = value
+    @status_time[device_name][status_name] = @current_time
+    @status_count[device_name][status_name] = @current_count
+    lookup_watchers(device_name, status_name).each {|watcher_device_name, reaction|
+      set_wakeup_if_possible(watcher_device_name, run_end_time) if reaction_immediate_at_beginning? reaction
     }
   end
-  private :update_status
+  private :internal_define_status2
 
-  def update_watch(device_name, device_watch_buffer)
-    wakeup_immediate = false
-    device_watch_buffer.each {|add_or_del, watchee_device_name, status_name, reaction|
-      case add_or_del
-      when :add
-        @watches[watchee_device_name][status_name][device_name] = reaction
-        if @status.has_key?(watchee_device_name) &&
-           @status[watchee_device_name].has_key?(status_name)
-          @watched_status_change[device_name][watchee_device_name][status_name] = @status[watchee_device_name][status_name]
-          wakeup_immediate ||= reaction_immediate_at_beginning? reaction
-        end
-      when :del
-        @watches[watchee_device_name][status_name].delete device_name
-        @watched_status_change[device_name][watchee_device_name].delete status_name
-      else
-        raise "unexpected add_or_del: #{add_or_del.inspect}"
+  def internal_modify_status(device_name, run_end_time, status_name, value)
+    internal_modify_status2(device_name, run_end_time, status_name, value)
+  end
+  private :internal_modify_status
+
+  def internal_modify_status2(device_name, run_end_time, status_name, value)
+    unless @status_value.has_key? device_name
+      raise ArgumentError, "device not defined: #{device_name}"
+    end
+    unless @status_value[device_name].has_key? status_name
+      raise ArgumentError, "device status not defined: #{device_name} #{status_name}"
+    end
+    @status_value[device_name][status_name] = value
+    @status_time[device_name][status_name] = @current_time
+    @status_count[device_name][status_name] = @current_count
+    lookup_watchers(device_name, status_name).each {|watcher_device_name, reaction|
+      set_wakeup_if_possible(watcher_device_name, run_end_time) if reaction_immediate_at_subsequent? reaction
+    }
+  end
+  private :internal_modify_status2
+
+  def internal_undefine_status(device_name, run_end_time, status_name)
+    unless @status_value.has_key? device_name
+      raise ArgumentError, "device not defined: #{device_name}"
+    end
+    unless @status_value[device_name].has_key? status_name
+      raise ArgumentError, "device status not defined: #{device_name} #{status_name}"
+    end
+    @status_value[device_name].delete status_name
+    @status_time[device_name][status_name] = @current_time
+    @status_count[device_name][status_name] = @current_count
+    lookup_watchers(device_name, status_name).each {|watcher_device_name, reaction|
+      set_wakeup_if_possible(watcher_device_name, run_end_time) if reaction_immediate_at_subsequent? reaction
+    }
+    internal_update_status(device_name, run_end_time, "_status_undefined_#{status_name}", run_end_time)
+  end
+  private :internal_update_status
+
+  def lookup_watchers(watchee_device_name, status_name)
+    @watchset.lookup_watchers(watchee_device_name, status_name)
+  end
+  private :lookup_watchers
+
+  def internal_add_watch(watcher_device_name, watchee_device_name_pat, status_name_pat, reaction)
+    @watchset.add(watchee_device_name_pat, status_name_pat, watcher_device_name, reaction)
+    matched_status_each(watchee_device_name_pat, status_name_pat) {|watchee_device_name, status_name|
+      if reaction_immediate_at_beginning? reaction
+        return true
       end
     }
-    wakeup_immediate
+    false
   end
-  private :update_watch
+  private :internal_add_watch
 
-  def notify_status_change(device_name, sleep_time, device_define_buffer, device_changed_buffer)
-    device_define_buffer.each {|status_name, _|
-      value = @status[device_name][status_name]
-      lookup_watchers(device_name, status_name).each {|watcher_device_name, reaction|
-        @watched_status_change[watcher_device_name][device_name][status_name] = value
-        set_wakeup_if_possible(watcher_device_name, sleep_time) if reaction_immediate_at_beginning? reaction
+  def matched_status_each(watchee_device_name_pat, status_name_pat)
+    matched_device_name_each(watchee_device_name_pat) {|watchee_device_name|
+      matched_status_name_each(watchee_device_name, status_name_pat) {|status_name|
+        yield watchee_device_name, status_name
       }
     }
-    device_changed_buffer.each {|status_name, _|
-      value = @status[device_name][status_name]
-      lookup_watchers(device_name, status_name).each {|watcher_device_name, reaction|
-        @watched_status_change[watcher_device_name][device_name][status_name] = value
-        set_wakeup_if_possible(watcher_device_name, sleep_time) if reaction_immediate_at_subsequent? reaction
+  end
+  private :matched_status_each
+
+  def matched_device_name_each(device_name_pat)
+    if /\*\z/ =~ device_name_pat
+      prefix = $`
+      @status_time.each {|device_name, _h|
+        if device_name.start_with? prefix
+          yield device_name
+        end
       }
-    }
+    else
+      yield device_name_pat
+    end
   end
-  private :notify_status_change
-
-  def lookup_watchers(watchee_device_name, status_name)
-    result = []
-    if @watches.has_key?(watchee_device_name) &&
-       @watches[watchee_device_name].has_key?(status_name)
-      @watches[watchee_device_name][status_name].each {|watcher_device_name, reaction|
-        result << [watcher_device_name, reaction]
+  private :matched_device_name_each
+
+  def matched_status_name_each(device_name, status_name_pat)
+    return unless @status_time.has_key? device_name
+    status_hash = @status_time[device_name]
+    if /\*\z/ =~ status_name_pat
+      prefix = $`
+      status_hash.each {|status_name, _value|
+        if status_name.start_with? prefix
+          yield status_name
+        end
       }
+    else
+      if status_hash.has_key? status_name_pat
+        yield status_name_pat
+      end
     end
-    result
   end
-  private :lookup_watchers
+  private :matched_status_name_each
+
+  def internal_del_watch(watcher_device_name, watchee_device_name_pat, status_name_pat)
+    @watchset.del(watchee_device_name_pat, status_name_pat, watcher_device_name)
+  end
+  private :internal_del_watch
 
   def set_wakeup_if_possible(device_name, time)
     loc = @schedule_locator[device_name]
     if !loc.in_queue?
-      loc.update [:wakeup, device_name], time
+      loc.update [:run_start, device_name], time
       @q.insert_locator loc
       return
     end
     case event_type = loc.value.first
-    when :wakeup # The device is sleeping now.
+    when :run_start # The device is sleeping now.
       if time < loc.priority
         loc.update_priority time
       end
-    when :sleep # The device is working now.
-      # Nothing to do. at_sleep itself checks arrived events at last.
+    when :run_end # The device is working now.
+      # Nothing to do. at_run_end itself checks arrived events at last.
     else
-      raise "unexpected event type: #{event_type}"
+      raise FSEvent::FSEventError, "unexpected event type: #{event_type}"
     end
   end
   private :set_wakeup_if_possible
 
-  def setup_next_schedule(device_name, loc, sleep_time, wakeup_immediate)
+  def setup_next_schedule(device_name, loc, run_end_time, wakeup_immediate)
     device = @devices[device_name]
-    wakeup_time = nil
+    run_start_time = nil
     if wakeup_immediate
-      wakeup_time = sleep_time
-    elsif wakeup_time = device.schedule.shift
-      if wakeup_time < sleep_time
-        wakeup_time = sleep_time
+      run_start_time = run_end_time
+    elsif run_start_time = device.schedule.shift
+      if run_start_time < run_end_time
+        run_start_time = run_end_time
       end
-      while device.schedule.first && device.schedule.first < sleep_time
+      while device.schedule.first && device.schedule.first < run_end_time
         device.schedule.shift
       end
     end
-    if wakeup_time
-      value = [:wakeup, device_name]
-      loc.update value, wakeup_time
+    if run_start_time
+      value = [:run_start, device_name]
+      loc.update value, run_start_time
       @q.insert_locator loc
     end
   end
   private :setup_next_schedule
 
-  def immediate_wakeup?(watcher_device_name)
-    return false unless @watched_status_change.has_key?(watcher_device_name)
-    @watched_status_change[watcher_device_name].each {|watchee_device_name, h|
-      h.each {|status_name, value|
-        lookup_watchers(watchee_device_name, status_name).each {|watcher_device_name2, reaction|
-          next if watcher_device_name != watcher_device_name2
-          return true if reaction_immediate_at_subsequent?(reaction)
+  def immediate_wakeup_self?(watcher_device_name, run_start_count)
+    @watchset.watcher_each(watcher_device_name) {|watchee_device_name_pat, status_name_pat, reaction|
+      if reaction_immediate_at_subsequent?(reaction)
+        matched_status_each(watchee_device_name_pat, status_name_pat) {|watchee_device_name, status_name|
+          if @status_count.has_key?(watchee_device_name) &&
+             @status_count[watchee_device_name].has_key?(status_name) &&
+             run_start_count <= @status_count[watchee_device_name][status_name]
+            return true
+          end
         }
-      }
+      end
     }
     false
   end
-  private :immediate_wakeup?
+  private :immediate_wakeup_self?
 
-  def unregister_device_internal(unregister_device_buffer)
-    unregister_device_buffer.each {|device_name|
-      device = @devices.delete device_name
-      @status.delete device_name
-      @watches.each {|watchee_device_name, h1|
-        h1.each {|status_name, h2|
-          h2.delete device_name
-        }
+  def internal_unregister_device(self_device_name, target_device_name)
+    if @status_value.has_key? target_device_name
+      @status_value[target_device_name].keys.each {|status_name|
+        next if /\A_/ =~ status_name
+        internal_undefine_status(target_device_name, @current_time, status_name)
       }
-      @watched_status_change.delete device_name
-      @status.delete device_name
-      loc = @schedule_locator.fetch(device_name)
-      device.unregistered
+    end
+    device = @devices.delete target_device_name
+    @status_value.delete target_device_name
+    @watchset.delete_watcher(target_device_name)
+    loc = @schedule_locator.delete target_device_name
+    if loc.in_queue?
       @q.delete_locator loc
-    }
+    end
+    device.unregistered
+    internal_update_status("_fsevent", @current_time, "_device_unregistered_#{target_device_name}", @current_time)
+    self_device_name == target_device_name
   end
-  private :unregister_device_internal
+  private :internal_unregister_device
 
 end