rx_ruby 0.0.2

data/lib/rx_ruby/concurrency/default_scheduler.rb

@@ -0,0 +1,51 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'singleton'
+require 'thread'
+require 'rx_ruby/concurrency/local_scheduler'
+require 'rx_ruby/concurrency/periodic_scheduler'
+require 'rx_ruby/subscriptions/subscription'
+require 'rx_ruby/subscriptions/single_assignment_subscription'
+require 'rx_ruby/subscriptions/composite_subscription'
+
+module RxRuby
+
+  # Represents an object that schedules units of work on the platform's default scheduler.
+  class DefaultScheduler < RxRuby::LocalScheduler
+
+    include Singleton
+    include RxRuby::PeriodicScheduler
+
+    # Schedules an action to be executed.
+    def schedule_with_state(state, action)
+      raise 'action cannot be nil' unless action
+
+      d = SingleAssignmentSubscription.new
+
+      t = Thread.new do
+        d.subscription = action.call self, state unless d.unsubscribed?
+      end
+
+      CompositeSubscription.new [d, Subscription.create { t.exit }]
+    end
+
+    # Schedules an action to be executed after dueTime
+    def schedule_relative_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+
+      dt = Scheduler.normalize due_time
+      return self.schedule_with_state state, action if dt == 0
+
+      d = SingleAssignmentSubscription.new
+
+      t = Thread.new do
+        sleep dt
+        Thread.new {
+          d.subscription = action.call self, state unless d.unsubscribed?
+        }
+      end
+
+      CompositeSubscription.new [d, Subscription.create { t.exit }]         
+    end
+  end
+end

data/lib/rx_ruby/concurrency/historical_scheduler.rb

@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/virtual_time_scheduler'
+require 'rx_ruby/internal/priority_queue'
+
+module RxRuby
+
+  # Provides a virtual time scheduler that uses Time for absolute time and Number for relative time.
+  class HistoricalScheduler < VirtualTimeScheduler
+
+    def initialize(clock = Time.at(0))
+      super
+      @clock = clock
+    end
+  end
+end

data/lib/rx_ruby/concurrency/immediate_scheduler.rb

@@ -0,0 +1,68 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'singleton'
+require 'thread'
+require 'rx_ruby/concurrency/local_scheduler'
+require 'rx_ruby/subscriptions/single_assignment_subscription'
+
+module RxRuby
+
+  # Represents an object that schedules units of work to run immediately on the current thread.
+  class ImmediateScheduler < LocalScheduler
+
+    include Singleton
+
+    # Schedules an action to be executed.
+    def schedule_with_state(state, action)
+      raise ArgumentError.new 'action cannot be nil' unless action
+      action.call AsyncLockScheduler.new, state
+    end
+
+    def schedule_relative_with_state(state, due_time, action)
+      raise ArgumentError.new 'action cannot be nil' unless action
+
+      dt = RxRuby::Scheduler.normalize due_time
+      sleep dt if dt > 0
+      action.call AsyncLockScheduler.new, state
+    end
+
+    private
+
+    class AsyncLockScheduler < LocalScheduler
+
+      def initialize
+          @gate = nil
+      end
+
+      def schedule_with_state(state, action)
+        m = SingleAssignmentSubscription.new
+
+        @gate = AsyncLock.new if @gate.nil?
+
+        @gate.wait do
+          m.subscription = action.call self, state unless m.unsubscribed?
+        end
+
+        m
+      end
+
+      def schedule_relative_with_state(state, due_time, action) 
+        return self.schedule_with_state state, action if due_time <= 0
+
+        m = SingleAssignmentSubscription.new
+
+        timer = Time.new
+
+        @gate = AsyncLock.new if @gate.nil?
+
+        @gate.wait do
+          sleep_time = Time.new - timer
+          sleep sleep_time if sleep_time > 0
+          m.subscription = action.call self, state unless m.unsubscribed?
+        end
+
+        m
+      end
+    end
+  end
+end

data/lib/rx_ruby/concurrency/local_scheduler.rb

@@ -0,0 +1,39 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/scheduler'
+
+module RxRuby
+  # Abstract base class for machine-local schedulers, using the local system clock for time-based operations.
+  class LocalScheduler
+
+    include Scheduler
+
+    # Gets the scheduler's notion of current time.
+    def now
+      Time.now
+    end
+
+    # Schedules an action to be executed.
+    def schedule_with_state(state, action)
+      raise 'action cannot be nil' unless action
+
+      schedule_relative_with_state(state, 0, action)
+    end
+
+    # Schedules an action to be executed at dueTime.
+    def schedule_absolute_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+
+      schedule_relative_with_state(state, (due_time - self.now), action)
+    end
+
+    def schedule_relative_with_state(state, due_time, action)
+      raise ArgumentError.new 'action cannot be nil' unless action
+
+      dt = RxRuby::Scheduler.normalize due_time
+      sleep dt if dt > 0
+      action.call(self, state)
+    end
+
+  end
+end

data/lib/rx_ruby/concurrency/periodic_scheduler.rb

@@ -0,0 +1,74 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+
+  # Provides periodic scheduling capabilities
+  module PeriodicScheduler
+
+    # Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities.
+    def schedule_periodic(period, action)
+      raise 'action cannot be nil' unless action
+      raise 'period cannot be less than zero' if period < 0
+
+      self.schedule_periodic_with_state(action, period, lambda {|a|
+        a.call
+        return a
+      })
+    end
+
+    # Schedules a periodic piece of work
+    def schedule_periodic_with_state(state, due_time, action)
+        raise 'action cannot be nil' unless action
+        raise 'due_time cannot be less than zero' if due_time < 0
+
+        state1 = state
+        gate = Mutex.new
+
+        PeriodicTimer.new due_time do 
+          gate.synchronize do
+            state1 = action.call state1
+          end
+        end
+    end
+
+    private
+
+    # Internal timer
+    class PeriodicTimer
+      def initialize(seconds, &action)
+        @seconds = seconds
+        @unsubscribed = false
+        @gate = Mutex.new
+
+        self.run_loop(&action)
+      end
+
+      def unsubscribe
+        @gate.synchronize do
+          @unsubscribed = true unless @unsubscribed
+        end
+      end
+
+      def time_block
+        start_time = Time.new
+        yield
+        Time.new - start_time
+      end
+
+      def run_loop
+        Thread.new do
+          should_run = true
+
+          elapsed = 0
+          while should_run
+            sleep @seconds - elapsed
+            elapsed = time_block { yield }
+            @gate.synchronize do
+              should_run = !@unsubscribed
+            end                    
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rx_ruby/concurrency/scheduled_item.rb

@@ -0,0 +1,42 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/subscriptions/single_assignment_subscription'
+
+module RxRuby
+  
+  # Represents a scheduled work item based on the materialization of an scheduler.schedule method call.
+  class ScheduledItem
+
+    include Comparable
+
+    attr_reader :due_time
+
+    def initialize(scheduler, state, due_time, &action)
+      @scheduler = scheduler
+      @state = state
+      @action = action
+      @due_time = due_time
+      @subscription = SingleAssignmentSubscription.new
+    end
+
+    # Gets whether the work item has received a cancellation request.
+    def cancelled?
+      @subscription.unsubscribed?
+    end
+
+    # Invokes the work item.
+    def invoke
+      @subscription.subscription = @action.call @scheduler, @state unless @subscription.unsubscribed?
+    end
+
+    def <=>(other)
+      return @due_time <=> other.due_time
+    end
+
+    # Cancels the work item by disposing the resource returned by invoke_core as soon as possible.
+    def cancel
+      @subscription.unsubscribe
+    end
+
+  end
+end

data/lib/rx_ruby/concurrency/scheduler.rb

@@ -0,0 +1,150 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+
+module RxRuby
+
+  # Module for scheduling actions
+  module Scheduler
+
+    # Gets the current time according to the local machine's system clock.
+    def self.now
+      Time.now
+    end
+
+    # Schedules an action to be executed.
+    def schedule(action)
+      raise 'action cannot be nil' unless action
+      schedule_with_state(action, method(:invoke))
+    end
+
+    # Schedules an action to be executed after the specified relative due time.
+    def schedule_relative(due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_relative_with_state(action, due_time, method(:invoke))
+    end
+
+    # Schedules an action to be executed at the specified absolute due time.
+    def schedule_absolute(due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_absolute_with_state(action, due_time, method(:invoke))
+    end
+
+    # Schedules an action to be executed recursively.
+    def schedule_recursive(action)
+      raise 'action cannot be nil' unless action
+      schedule_recursive_with_state(action, lambda {|_action, _self| _action.call(lambda { _self.call(_action) }) })
+    end
+
+    # Schedules an action to be executed recursively.
+    def schedule_recursive_with_state(state, action)
+      raise 'action cannot be nil' unless action
+      schedule_with_state({ :state => state, :action => action}, method(:invoke_recursive))
+    end
+
+    # Schedules an action to be executed recursively after a specified relative due time.
+    def schedule_recursive_relative(due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_recursive_relative_with_state(action, due_time, lambda {|_action, _self| _action.call(lambda {|dt| _self.call(_action, dt) }) })
+    end
+
+    # Schedules an action to be executed recursively after a specified relative due time.
+    def schedule_recursive_relative_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_relative_with_state(
+        { :state => state, :action => action}, 
+        due_time,
+        lambda { |sched, pair| invoke_recursive_time(sched, pair, 'schedule_relative_with_state') }
+      )
+    end
+
+    # Schedules an action to be executed recursively after a specified absolute due time.
+    def schedule_recursive_absolute(due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_recursive_absolute_with_state(action, due_time, lambda {|_action, _self| _action.call(lambda {|dt| _self.call(_action, dt) }) })
+    end
+
+    # Schedules an action to be executed recursively after a specified absolute due time.
+    def schedule_recursive_absolute_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+      schedule_absolute_with_state(
+        { :state => state, :action => action}, 
+        due_time,
+        lambda { |sched, pair| invoke_recursive_time(sched, pair, 'schedule_absolute_with_state') }
+      )
+    end
+
+    # Normalizes the specified TimeSpan value to a positive value.
+    def self.normalize(time_span)
+      time_span < 0 ? 0 : time_span
+    end
+
+    private
+
+    def invoke(scheduler, action)
+      action.call()
+      Subscription.empty
+    end
+
+    def invoke_recursive(scheduler, pair)
+      group = CompositeSubscription.new
+      gate = Mutex.new
+      state = pair[:state]
+      action = pair[:action]
+
+      recursive_action = lambda {|state1|
+        action.call(state1, lambda {|state2|  
+          is_added = false
+          is_done = false
+          d = nil
+          d = scheduler.schedule_with_state(state2, lambda do |_, state3|
+            gate.synchronize do
+              if is_added
+                group.delete(d)
+              else
+                is_done = true
+              end
+            end
+
+            recursive_action.call(state3)
+            Subscription.empty
+          end)
+
+          gate.synchronize do
+            unless is_done
+              group.push(d)
+              is_added = true
+            end
+          end
+        })
+      }
+
+      recursive_action.call(state)
+      group
+    end
+
+    def invoke_recursive_time(scheduler, pair, method)
+      group = CompositeSubscription.new
+      gate = Mutex.new
+      state = pair[:state]
+      action = pair[:action]
+
+      recursive_action = ->(state1) do
+        internal_action = ->(state2, due_time1) do
+
+          d = scheduler.send(method, state2, due_time1, lambda do |_, state3|
+            gate.synchronize do
+              group.delete(d)
+            end
+            recursive_action.call(state3)
+            Subscription.empty
+          end)
+        end
+        action.call(state1, internal_action)
+      end
+
+      recursive_action.call(state)
+      group            
+    end
+  end
+end