concurrent-ruby 0.7.0.rc0-x64-mingw32

data/lib/concurrent/logging.rb

@@ -0,0 +1,17 @@
+require 'logger'
+
+module Concurrent
+  # Include where logging is needed
+  module Logging
+    include Logger::Severity
+
+    # Logs through {Configuration#logger}, it can be overridden by setting @logger
+    # @param [Integer] level one of Logger::Severity constants
+    # @param [String] progname e.g. a path of an Actor
+    # @param [String, nil] message when nil block is used to generate the message
+    # @yieldreturn [String] a message
+    def log(level, progname, message = nil, &block)
+      (@logger || Concurrent.configuration.logger).call level, progname, message, &block
+    end
+  end
+end

data/lib/concurrent/mvar.rb

@@ -0,0 +1,200 @@
+require 'concurrent/dereferenceable'
+require 'concurrent/atomic/condition'
+require 'concurrent/atomic/event'
+
+module Concurrent
+
+  # An `MVar` is a single-element container that blocks on `get` if it is empty,
+  # and blocks on `put` if it is full. It is safe to use an `MVar` from
+  # multiple threads. `MVar` can be seen as a single-element blocking queue, or
+  # a rendezvous variable.
+  #
+  # An `MVar` is typically used to transfer objects between threads, where the
+  # sending thread will block if the previous message hasn't been taken yet by the
+  # receiving thread. It can also be used to control access to some global shared
+  # state, where threads `take` the value, perform some operation, and then
+  # `put` it back.
+  class MVar
+
+    include Dereferenceable
+
+    # Unique value that represents that an `MVar` was empty
+    EMPTY = Object.new
+
+    # Unique value that represents that an `MVar` timed out before it was able
+    # to produce a value.
+    TIMEOUT = Object.new
+
+    # Create a new `MVar`, either empty or with an initial value.
+    #
+    # @param [Hash] opts the options controlling how the future will be processed
+    # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
+    #   operation pool (for long-running operations), when `false` will execute the future on the
+    #   global task pool (for short-running tasks)
+    # @option opts [object] :executor when provided will run all operations on
+    #   this executor rather than the global thread pool (overrides :operation)
+    # @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
+    # @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
+    # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
+    #   returning the value returned from the proc
+    def initialize(value = EMPTY, opts = {})
+      @value = value
+      @mutex = Mutex.new
+      @empty_condition = Condition.new
+      @full_condition = Condition.new
+      set_deref_options(opts)
+    end
+
+    # Remove the value from an `MVar`, leaving it empty, and blocking if there
+    # isn't a value. A timeout can be set to limit the time spent blocked, in
+    # which case it returns `TIMEOUT` if the time is exceeded.
+    # @return [Object] the value that was taken, or `TIMEOUT`
+    def take(timeout = nil)
+      @mutex.synchronize do
+        wait_for_full(timeout)
+
+        # If we timed out we'll still be empty
+        if unlocked_full?
+          value = @value
+          @value = EMPTY
+          @empty_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    # Put a value into an `MVar`, blocking if there is already a value until
+    # it is empty. A timeout can be set to limit the time spent blocked, in
+    # which case it returns `TIMEOUT` if the time is exceeded.
+    # @return [Object] the value that was put, or `TIMEOUT`
+    def put(value, timeout = nil)
+      @mutex.synchronize do
+        wait_for_empty(timeout)
+
+        # If we timed out we won't be empty
+        if unlocked_empty?
+          @value = value
+          @full_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    # Atomically `take`, yield the value to a block for transformation, and then
+    # `put` the transformed value. Returns the transformed value. A timeout can
+    # be set to limit the time spent blocked, in which case it returns `TIMEOUT`
+    # if the time is exceeded.
+    # @return [Object] the transformed value, or `TIMEOUT`
+    def modify(timeout = nil)
+      raise ArgumentError.new('no block given') unless block_given?
+
+      @mutex.synchronize do
+        wait_for_full(timeout)
+
+        # If we timed out we'll still be empty
+        if unlocked_full?
+          value = @value
+          @value = yield value
+          @full_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    # Non-blocking version of `take`, that returns `EMPTY` instead of blocking.
+    def try_take!
+      @mutex.synchronize do
+        if unlocked_full?
+          value = @value
+          @value = EMPTY
+          @empty_condition.signal
+          apply_deref_options(value)
+        else
+          EMPTY
+        end
+      end
+    end
+
+    # Non-blocking version of `put`, that returns whether or not it was successful.
+    def try_put!(value)
+      @mutex.synchronize do
+        if unlocked_empty?
+          @value = value
+          @full_condition.signal
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # Non-blocking version of `put` that will overwrite an existing value.
+    def set!(value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = value
+        @full_condition.signal
+        apply_deref_options(old_value)
+      end
+    end
+
+    # Non-blocking version of `modify` that will yield with `EMPTY` if there is no value yet.
+    def modify!
+      raise ArgumentError.new('no block given') unless block_given?
+
+      @mutex.synchronize do
+        value = @value
+        @value = yield value
+        if unlocked_empty?
+          @empty_condition.signal
+        else
+          @full_condition.signal
+        end
+        apply_deref_options(value)
+      end
+    end
+
+    # Returns if the `MVar` is currently empty.
+    def empty?
+      @mutex.synchronize { @value == EMPTY }
+    end
+
+    # Returns if the `MVar` currently contains a value.
+    def full?
+      not empty?
+    end
+
+    private
+
+    def unlocked_empty?
+      @value == EMPTY
+    end
+
+    def unlocked_full?
+      ! unlocked_empty?
+    end
+
+    def wait_for_full(timeout)
+      wait_while(@full_condition, timeout) { unlocked_empty? }
+    end
+
+    def wait_for_empty(timeout)
+      wait_while(@empty_condition, timeout) { unlocked_full? }
+    end
+
+    def wait_while(condition, timeout)
+      remaining = Condition::Result.new(timeout)
+      while yield && remaining.can_wait?
+        remaining = condition.wait(@mutex, remaining.remaining_time)
+      end
+    end
+
+  end
+
+end

data/lib/concurrent/obligation.rb

@@ -0,0 +1,171 @@
+require 'thread'
+require 'timeout'
+
+require 'concurrent/dereferenceable'
+require 'concurrent/atomic/event'
+
+module Concurrent
+
+  module Obligation
+    include Dereferenceable
+
+    # Has the obligation been fulfilled?
+    # @return [Boolean]
+    def fulfilled?
+      state == :fulfilled
+    end
+    alias_method :realized?, :fulfilled?
+
+    # Has the obligation been rejected?
+    # @return [Boolean]
+    def rejected?
+      state == :rejected
+    end
+
+    # Is obligation completion still pending?
+    # @return [Boolean]
+    def pending?
+      state == :pending
+    end
+
+    # Is the obligation still unscheduled?
+    # @return [Boolean]
+    def unscheduled?
+      state == :unscheduled
+    end
+
+    def completed?
+      [:fulfilled, :rejected].include? state
+    end
+
+    def incomplete?
+      [:unscheduled, :pending].include? state
+    end
+
+    # @return [Object] see Dereferenceable#deref
+    def value(timeout = nil)
+      wait timeout
+      deref
+    end
+
+    # wait until Obligation is #complete?
+    # @param [Numeric] timeout the maximum time in second to wait.
+    # @return [Obligation] self
+    def wait(timeout = nil)
+      event.wait(timeout) if timeout != 0 && incomplete?
+      self
+    end
+
+    # wait until Obligation is #complete?
+    # @param [Numeric] timeout the maximum time in second to wait.
+    # @return [Obligation] self
+    # @raise [Exception] when #rejected? it raises #reason
+    def no_error!(timeout = nil)
+      wait(timeout).tap { raise self if rejected? }
+    end
+
+    # @raise [Exception] when #rejected? it raises #reason
+    # @return [Object] see Dereferenceable#deref
+    def value!(timeout = nil)
+      wait(timeout)
+      if rejected?
+        raise self
+      else
+        deref
+      end
+    end
+
+    def state
+      mutex.lock
+      @state
+    ensure
+      mutex.unlock
+    end
+
+    def reason
+      mutex.lock
+      @reason
+    ensure
+      mutex.unlock
+    end
+
+    # @example allows Obligation to be risen
+    #   rejected_ivar = Ivar.new.fail
+    #   raise rejected_ivar
+    def exception(*args)
+      raise 'obligation is not rejected' unless rejected?
+      reason.exception(*args)
+    end
+
+    protected
+
+    # @!visibility private
+    def init_obligation # :nodoc:
+      init_mutex
+      @event = Event.new
+    end
+
+    # @!visibility private
+    def event # :nodoc:
+      @event
+    end
+
+    # @!visibility private
+    def set_state(success, value, reason) # :nodoc:
+      if success
+        @value = value
+        @state = :fulfilled
+      else
+        @reason = reason
+        @state  = :rejected
+      end
+    end
+
+    # @!visibility private
+    def state=(value) # :nodoc:
+      mutex.lock
+      @state = value
+    ensure
+      mutex.unlock
+    end
+
+    # atomic compare and set operation
+    # state is set to next_state only if current state is == expected_current
+    #
+    # @param [Symbol] next_state
+    # @param [Symbol] expected_current
+    # 
+    # @return [Boolean] true is state is changed, false otherwise
+    #
+    # @!visibility private
+    def compare_and_set_state(next_state, expected_current) # :nodoc:
+      mutex.lock
+      if @state == expected_current
+        @state = next_state
+        true
+      else
+        false
+      end
+    ensure
+      mutex.unlock
+    end
+
+    # executes the block within mutex if current state is included in expected_states
+    #
+    # @return block value if executed, false otherwise
+    #
+    # @!visibility private
+    def if_state(*expected_states) # :nodoc:
+      mutex.lock
+      raise ArgumentError.new('no block given') unless block_given?
+
+      if expected_states.include? @state
+        yield
+      else
+        false
+      end
+    ensure
+      mutex.unlock
+    end
+  end
+end

data/lib/concurrent/observable.rb

@@ -0,0 +1,40 @@
+require 'concurrent/atomic/copy_on_notify_observer_set'
+require 'concurrent/atomic/copy_on_write_observer_set'
+
+module Concurrent
+
+  module Observable
+
+    # @return [Object] the added observer
+    def add_observer(*args, &block)
+      observers.add_observer(*args, &block)
+    end
+
+    # as #add_observer but it can be used for chaining
+    # @return [Observable] self
+    def with_observer(*args, &block)
+      add_observer *args, &block
+      self
+    end
+
+    # @return [Object] the deleted observer
+    def delete_observer(*args)
+      observers.delete_observer(*args)
+    end
+
+    # @return [Observable] self
+    def delete_observers
+      observers.delete_observers
+      self
+    end
+
+    # @return [Integer] the observers count
+    def count_observers
+      observers.count_observers
+    end
+
+    protected
+
+    attr_accessor :observers
+  end
+end

data/lib/concurrent/options_parser.rb

@@ -0,0 +1,46 @@
+module Concurrent
+
+  # A mixin module for parsing options hashes related to gem-level configuration.
+  module OptionsParser
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :executor (`nil`) when set use the given `Executor` instance
+    # @option opts [Boolean] :operation (`false`) when true use the global operation pool
+    # @option opts [Boolean] :task (`true`) when true use the global task pool
+    #
+    # @return [Executor] the requested thread pool (default: global task pool)
+    def get_executor_from(opts = {})
+      if opts[:executor]
+        opts[:executor]
+      elsif opts[:operation] == true || opts[:task] == false
+        Concurrent.configuration.global_operation_pool
+      else
+        Concurrent.configuration.global_task_pool
+      end
+    end
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
+    #
+    # @return [Executor] the requested thread pool (default: global task pool)
+    def get_task_executor_from(opts = {})
+      opts[:task_executor] || opts[:executor] || Concurrent.configuration.global_task_pool
+    end
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @param [Hash] opts the options defining the requested executor
+    # @option opts [Executor] :task_executor (`nil`) when set use the given `Executor` instance
+    #
+    # @return [Executor] the requested thread pool (default: global operation pool)
+    def get_operation_executor_from(opts = {})
+      opts[:operation_executor] || opts[:executor] || Concurrent.configuration.global_operation_pool
+    end
+
+    extend self
+  end
+end