concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/actress.rb

@@ -1,3 +0,0 @@
-require 'concurrent/actor'
-
-Concurrent::Actress = Concurrent::Actor

data/lib/concurrent/agent.rb

@@ -1,209 +0,0 @@
-require 'thread'
-
-require 'concurrent/dereferenceable'
-require 'concurrent/observable'
-require 'concurrent/options_parser'
-require 'concurrent/utility/timeout'
-require 'concurrent/logging'
-
-module Concurrent
-
-  # {include:file:doc/agent.md}
-  #
-  # @!attribute [r] timeout
-  #   @return [Fixnum] the maximum number of seconds before an update is cancelled
-  class Agent
-    include Dereferenceable
-    include Concurrent::Observable
-    include Logging
-
-    attr_reader :timeout, :task_executor, :operation_executor
-
-    # Initialize a new Agent with the given initial value and provided options.
-    #
-    # @param [Object] initial the initial value
-    # @param [Hash] opts the options used to define the behavior at update and deref
-    #
-    # @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(initial, opts = {})
-      @value                = initial
-      @rescuers             = []
-      @validator            = Proc.new { |result| true }
-      self.observers        = CopyOnWriteObserverSet.new
-      @serialized_execution = SerializedExecution.new
-      @task_executor        = OptionsParser.get_task_executor_from(opts)
-      @operation_executor   = OptionsParser.get_operation_executor_from(opts)
-      init_mutex
-      set_deref_options(opts)
-    end
-
-    # Specifies a block operation to be performed when an update operation raises
-    # an exception. Rescue blocks will be checked in order they were added. The first
-    # block for which the raised exception "is-a" subclass of the given `clazz` will
-    # be called. If no `clazz` is given the block will match any caught exception.
-    # This behavior is intended to be identical to Ruby's `begin/rescue/end` behavior.
-    # Any number of rescue handlers can be added. If no rescue handlers are added then
-    # caught exceptions will be suppressed.
-    #
-    # @param [Exception] clazz the class of exception to catch
-    # @yield the block to be called when a matching exception is caught
-    # @yieldparam [StandardError] ex the caught exception
-    #
-    # @example
-    #   score = Concurrent::Agent.new(0).
-    #             rescue(NoMethodError){|ex| puts "Bam!" }.
-    #             rescue(ArgumentError){|ex| puts "Pow!" }.
-    #             rescue{|ex| puts "Boom!" }
-    #   
-    #   score << proc{|current| raise ArgumentError }
-    #   sleep(0.1)
-    #   #=> puts "Pow!"
-    def rescue(clazz = StandardError, &block)
-      unless block.nil?
-        mutex.synchronize do
-          @rescuers << Rescuer.new(clazz, block)
-        end
-      end
-      self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    # A block operation to be performed after every update to validate if the new
-    # value is valid. If the new value is not valid then the current value is not
-    # updated. If no validator is provided then all updates are considered valid.
-    #
-    # @yield the block to be called after every update operation to determine if
-    #   the result is valid
-    # @yieldparam [Object] value the result of the last update operation
-    # @yieldreturn [Boolean] true if the value is valid else false
-    def validate(&block)
-
-      unless block.nil?
-        begin
-          mutex.lock
-          @validator = block
-        ensure
-          mutex.unlock
-        end
-      end
-      self
-    end
-    alias_method :validates, :validate
-    alias_method :validate_with, :validate
-    alias_method :validates_with, :validate
-
-    # Update the current value with the result of the given block operation,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post(&block)
-      post_on(@task_executor, &block)
-    end
-
-    # Update the current value with the result of the given block operation,
-    # block can do blocking calls
-    #
-    # @param [Fixnum, nil] timeout maximum number of seconds before an update is cancelled
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post_off(timeout = nil, &block)
-      block = if timeout
-                lambda { |value| Concurrent::timeout(timeout) { block.call(value) } }
-              else
-                block
-              end
-      post_on(@operation_executor, &block)
-    end
-
-    # Update the current value with the result of the given block operation,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the operation to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    def <<(block)
-      post(&block)
-      self
-    end
-
-    # Waits/blocks until all the updates sent before this call are done.
-    #
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Boolean] false on timeout, true otherwise
-    def await(timeout = nil)
-      done = Event.new
-      post { |val| done.set; val }
-      done.wait timeout
-    end
-
-    private
-
-    def post_on(executor, &block)
-      return nil if block.nil?
-      @serialized_execution.post(executor) { work(&block) }
-      true
-    end
-
-    # @!visibility private
-    Rescuer = Struct.new(:clazz, :block) # :nodoc:
-
-    # @!visibility private
-    def try_rescue(ex) # :nodoc:
-      rescuer = mutex.synchronize do
-        @rescuers.find { |r| ex.is_a?(r.clazz) }
-      end
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => ex
-      # suppress
-      log DEBUG, ex
-    end
-
-    # @!visibility private
-    def work(&handler) # :nodoc:
-      validator, value = mutex.synchronize { [@validator, @value] }
-
-      begin
-        result = handler.call(value)
-        valid  = validator.call(result)
-      rescue Exception => ex
-        exception = ex
-      end
-
-      begin
-        mutex.lock
-        should_notify = if !exception && valid
-                          @value = result
-                          true
-                        end
-      ensure
-        mutex.unlock
-      end
-
-      if should_notify
-        time = Time.now
-        observers.notify_observers { [time, self.value] }
-      end
-
-      try_rescue(exception)
-    end
-  end
-end

data/lib/concurrent/atomic.rb

@@ -1,92 +0,0 @@
-#####################################################################
-# Attempt to check for the deprecated ruby-atomic gem and warn the
-# user that they should use the new implementation instead.
-
-if defined?(Atomic)
-  warn <<-RUBY
-[ATOMIC] Detected an `Atomic` class, which may indicate a dependency
-on the ruby-atomic gem. That gem has been deprecated and merged into
-the concurrent-ruby gem. Please use the Concurrent::Atomic class for
-atomic references and not the Atomic class.
-RUBY
-end
-#####################################################################
-
-require_relative '../extension_helper'
-require 'concurrent/atomic_reference/concurrent_update_error'
-require 'concurrent/atomic_reference/mutex_atomic'
-
-begin
-  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
-  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
-    ruby_engine = 'mutex_atomic'
-  else
-    ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
-  end
-
-  require "concurrent/atomic_reference/#{ruby_engine}"
-rescue LoadError
-  #warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
-end
-
-if defined? Concurrent::JavaAtomic
-
-  # @!macro [attach] atomic_reference
-  #
-  #   An object reference that may be updated atomically.
-  #
-  #       Testing with ruby 2.1.2
-  #       
-  #       *** Sequential updates ***
-  #                        user     system      total        real
-  #       no lock      0.000000   0.000000   0.000000 (  0.005502)
-  #       mutex        0.030000   0.000000   0.030000 (  0.025158)
-  #       MutexAtomic  0.100000   0.000000   0.100000 (  0.103096)
-  #       CAtomic      0.040000   0.000000   0.040000 (  0.034012)
-  #       
-  #       *** Parallel updates ***
-  #                        user     system      total        real
-  #       no lock      0.010000   0.000000   0.010000 (  0.009387)
-  #       mutex        0.030000   0.010000   0.040000 (  0.032545)
-  #       MutexAtomic  0.830000   2.280000   3.110000 (  2.146622)
-  #       CAtomic      0.040000   0.000000   0.040000 (  0.038332)
-  #
-  #       Testing with jruby 1.9.3
-  #       
-  #       *** Sequential updates ***
-  #                        user     system      total        real
-  #       no lock      0.170000   0.000000   0.170000 (  0.051000)
-  #       mutex        0.370000   0.010000   0.380000 (  0.121000)
-  #       MutexAtomic  1.530000   0.020000   1.550000 (  0.471000)
-  #       JavaAtomic   0.370000   0.010000   0.380000 (  0.112000)
-  #       
-  #       *** Parallel updates ***
-  #                        user     system      total        real
-  #       no lock      0.390000   0.000000   0.390000 (  0.105000)
-  #       mutex        0.480000   0.040000   0.520000 (  0.145000)
-  #       MutexAtomic  1.600000   0.180000   1.780000 (  0.511000)
-  #       JavaAtomic   0.460000   0.010000   0.470000 (  0.131000)
-  #
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
-  class Concurrent::Atomic < Concurrent::JavaAtomic
-  end
-
-elsif defined? Concurrent::RbxAtomic
-
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::RbxAtomic
-  end
-
-elsif defined? Concurrent::CAtomic
-
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::CAtomic
-  end
-
-else
-
-  # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::MutexAtomic
-  end
-end

data/lib/concurrent/atomic/copy_on_notify_observer_set.rb

@@ -1,118 +0,0 @@
-module Concurrent
-
-  # A thread safe observer set implemented using copy-on-read approach:
-  # observers are added and removed from a thread safe collection; every time
-  # a notification is required the internal data structure is copied to
-  # prevent concurrency issues
-  class CopyOnNotifyObserverSet
-
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-
-    # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
-    # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
-    # @return [Object] the added observer
-    def add_observer(observer=nil, func=:update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError.new('cannot provide both an observer and a block')
-      end
-
-      if block
-        observer = block
-        func = :call
-      end
-
-      begin
-        @mutex.lock
-        @observers[observer] = func
-      ensure
-        @mutex.unlock
-      end
-
-        observer
-    end
-
-    # @param [Object] observer the observer to remove
-    # @return [Object] the deleted observer
-    def delete_observer(observer)
-      @mutex.lock
-      @observers.delete(observer)
-      @mutex.unlock
-
-      observer
-    end
-
-    # Deletes all observers
-    # @return [CopyOnWriteObserverSet] self
-    def delete_observers
-      @mutex.lock
-      @observers.clear
-      @mutex.unlock
-
-      self
-    end
-
-    # @return [Integer] the observers count
-    def count_observers
-      @mutex.lock
-      result = @observers.count
-      @mutex.unlock
-
-      result
-    end
-
-    # Notifies all registered observers with optional args
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_observers(*args, &block)
-      observers = duplicate_observers
-      notify_to(observers, *args, &block)
-
-      self
-    end
-
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_and_delete_observers(*args, &block)
-      observers = duplicate_and_clear_observers
-      notify_to(observers, *args, &block)
-
-      self
-    end
-
-    private
-
-    def duplicate_and_clear_observers
-      @mutex.lock
-      observers = @observers.dup
-      @observers.clear
-      @mutex.unlock
-
-      observers
-    end
-
-    def duplicate_observers
-      @mutex.lock
-      observers = @observers.dup
-      @mutex.unlock
-
-      observers
-    end
-
-    def notify_to(observers, *args)
-      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-  end
-end

data/lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -1,117 +0,0 @@
-module Concurrent
-
-  # A thread safe observer set implemented using copy-on-write approach:
-  # every time an observer is added or removed the whole internal data structure is
-  # duplicated and replaced with a new one.
-  class CopyOnWriteObserverSet
-
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-
-    # Adds an observer to this set
-    # If a block is passed, the observer will be created by this method and no other params should be passed
-    # @param [Object] observer the observer to add
-    # @param [Symbol] func the function to call on the observer during notification. Default is :update
-    # @return [Object] the added observer
-    def add_observer(observer=nil, func=:update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError.new('cannot provide both an observer and a block')
-      end
-
-      if block
-        observer = block
-        func = :call
-      end
-
-      begin
-        @mutex.lock
-        new_observers = @observers.dup
-        new_observers[observer] = func
-        @observers = new_observers
-        observer
-      ensure
-        @mutex.unlock
-      end
-    end
-
-    # @param [Object] observer the observer to remove
-    # @return [Object] the deleted observer
-    def delete_observer(observer)
-      @mutex.lock
-      new_observers = @observers.dup
-      new_observers.delete(observer)
-      @observers = new_observers
-      observer
-    ensure
-      @mutex.unlock
-    end
-
-    # Deletes all observers
-    # @return [CopyOnWriteObserverSet] self
-    def delete_observers
-      self.observers = {}
-      self
-    end
-
-
-    # @return [Integer] the observers count
-    def count_observers
-      observers.count
-    end
-
-    # Notifies all registered observers with optional args
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_observers(*args, &block)
-      notify_to(observers, *args, &block)
-      self
-    end
-
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args arguments to be passed to each observer
-    # @return [CopyOnWriteObserverSet] self
-    def notify_and_delete_observers(*args, &block)
-      old = clear_observers_and_return_old
-      notify_to(old, *args, &block)
-      self
-    end
-
-    private
-
-    def notify_to(observers, *args)
-      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-
-    def observers
-      @mutex.lock
-      @observers
-    ensure
-      @mutex.unlock
-    end
-
-    def observers=(new_set)
-      @mutex.lock
-      @observers = new_set
-    ensure
-      @mutex.unlock
-    end
-
-    def clear_observers_and_return_old
-      @mutex.lock
-      old_observers = @observers
-      @observers = {}
-      old_observers
-    ensure
-      @mutex.unlock
-    end
-  end
-end