concurrent-ruby 1.0.5 → 1.1.0.pre1

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -1,81 +0,0 @@
-require 'concurrent/atomic_reference/concurrent_update_error'
-
-module Concurrent
-
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro [attach] atomic_reference_method_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. May retry if the value changes
-    # during the block's execution.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @return [Object] the new value
-    def update
-      true until compare_and_set(old_value = get, new_value = yield(old_value))
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Return nil if the update fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This method was altered to avoid raising an exception by default.
-    # Instead, this method now returns `nil` in case of failure. For more info,
-    # please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update!
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Raise an exception if the update
-    # fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This behavior mimics the behavior of the original
-    # `AtomicReference#try_update` API. The reason this was changed was to
-    # avoid raising exceptions (which are inherently slow) by default. For more
-    # info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value
-    #
-    # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_value = get
-      new_value = yield old_value
-      unless compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-end

data/lib/concurrent/atomic_reference/jruby+truffle.rb

@@ -1,2 +0,0 @@
-require 'atomic'
-require 'concurrent/atomic_reference/rbx'

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,16 +0,0 @@
-require 'concurrent/synchronization'
-
-if defined?(Concurrent::JavaAtomicReference)
-  require 'concurrent/atomic_reference/direct_update'
-
-  module Concurrent
-
-    # @!macro atomic_reference
-    #
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaAtomicReference
-      include Concurrent::AtomicDirectUpdate
-    end
-  end
-end

data/lib/concurrent/atomic_reference/rbx.rb

@@ -1,22 +0,0 @@
-require 'concurrent/atomic_reference/direct_update'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-module Concurrent
-
-  # @!macro atomic_reference
-  #
-  # @note Extends `Rubinius::AtomicReference` version adding aliases
-  #   and numeric logic.
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RbxAtomicReference < Rubinius::AtomicReference
-    alias _compare_and_set compare_and_set
-    include Concurrent::AtomicDirectUpdate
-    include Concurrent::AtomicNumericCompareAndSetWrapper
-
-    alias_method :value, :get
-    alias_method :value=, :set
-    alias_method :swap, :get_and_set
-  end
-end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,32 +0,0 @@
-if defined? Concurrent::CAtomicReference
-  require 'concurrent/synchronization'
-  require 'concurrent/atomic_reference/direct_update'
-  require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-  module Concurrent
-
-    # @!macro atomic_reference
-    #
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class CAtomicReference
-      include Concurrent::AtomicDirectUpdate
-      include Concurrent::AtomicNumericCompareAndSetWrapper
-
-      # @!method initialize
-      #   @!macro atomic_reference_method_initialize
-
-      # @!method get
-      #   @!macro atomic_reference_method_get
-
-      # @!method set
-      #   @!macro atomic_reference_method_set
-
-      # @!method get_and_set
-      #   @!macro atomic_reference_method_get_and_set
-
-      # @!method _compare_and_set
-      #   @!macro atomic_reference_method_compare_and_set
-    end
-  end
-end

data/lib/concurrent/edge.rb

@@ -1,26 +0,0 @@
-module Concurrent
-
-  # A submodule for unstable, highly experimental features that are likely to
-  # change often and which may never become part of the core gem. Also for
-  # new, experimental version of abstractions already in the core gem.
-  #
-  # Most new features should start in this module, clearly indicating the
-  # experimental and unstable nature of the feature. Once a feature becomes
-  # more stable and is a candidate for inclusion in the core gem it should
-  # be moved up to the `Concurrent` module, where it would reside once merged
-  # into the core gem.
-  #
-  # The only exception to this is for features which *replace* features from
-  # the core gem in ways that are breaking and not backward compatible. These
-  # features should remain in this module until merged into the core gem. This
-  # will prevent namespace collisions.
-  #
-  # @!macro [attach] edge_warning
-  #   @api Edge
-  #   @note **Edge Feature:** Edge features are under active development and may change frequently. They are expected not to
-  #     keep backward compatibility (there may also lack tests and documentation). Semantic versions will
-  #     be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move
-  #     to `concurrent-ruby` when final.
-  module Edge
-  end
-end

data/lib/concurrent/lazy_register.rb

@@ -1,81 +0,0 @@
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/delay'
-
-module Concurrent
-
-  # Hash-like collection that store lazys evaluated values.
-  #
-  # @example
-  #   register = Concurrent::LazyRegister.new
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
-  #   register[:key]
-  #   #=> nil
-  #   register.add(:key) { Concurrent::Actor.spawn!(Actor::AdHoc, :ping) { -> message { message } } }
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
-  #   register[:key]
-  #   #=> #<Concurrent::Actor::Reference /ping (Concurrent::Actor::AdHoc)>
-  #
-  # @!macro edge_warning
-  class LazyRegister < Synchronization::Object
-
-    private(*attr_atomic(:data))
-
-    def initialize
-      super
-      self.data = {}
-    end
-
-    # Element reference. Retrieves the value object corresponding to the
-    # key object. Returns nil if the key is not found. Raises an exception
-    # if the stored item raised an exception when the block was evaluated.
-    #
-    # @param [Object] key
-    # @return [Object] value stored for the key or nil if the key is not found
-    #
-    # @raise Exception when the initialization block fails
-    def [](key)
-      delay = data[key]
-      delay ? delay.value! : nil
-    end
-
-    # Returns true if the given key is present.
-    #
-    # @param [Object] key
-    # @return [true, false] if the key is registered
-    def registered?(key)
-      data.key?(key)
-    end
-
-    alias_method :key?, :registered?
-    alias_method :has_key?, :registered?
-
-    # Element assignment. Associates the value given by value with the
-    # key given by key.
-    #
-    # @param [Object] key
-    # @yield the object to store under the key
-    #
-    # @return [LazyRegister] self
-    def register(key, &block)
-      delay = Delay.new(executor: :immediate, &block)
-      update_data { |h| h.merge(key => delay) }
-      self
-    end
-
-    alias_method :add, :register
-    alias_method :store, :register
-
-    # Un-registers the object under key, realized or not.
-    #
-    # @param [Object] key
-    #
-    # @return [LazyRegister] self
-    def unregister(key)
-      update_data { |h| h.dup.tap { |j| j.delete(key) } }
-      self
-    end
-
-    alias_method :remove, :unregister
-    alias_method :delete, :unregister
-  end
-end

data/lib/concurrent/synchronization/truffle_lockable_object.rb

@@ -1,9 +0,0 @@
-module Concurrent
-  module Synchronization
-    class TruffleLockableObject < AbstractLockableObject
-      def new(*)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/concurrent/synchronization/truffle_object.rb

@@ -1,31 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    module TruffleAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          # TODO may not always be available
-          attr_atomic(*names)
-        end
-      end
-
-      def full_memory_barrier
-        Truffle::System.full_memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class TruffleObject < AbstractObject
-      include TruffleAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end

data/lib/concurrent/thread_safe/util/array_hash_rbx.rb

@@ -1,30 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-  module ThreadSafe
-    module Util
-      def self.make_synchronized_on_rbx(klass)
-        klass.class_eval do
-          private
-          def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
-          end
-
-          def self.allocate
-            obj = super
-            obj.send(:_mon_initialize)
-            obj
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args)
-              @_monitor.synchronize { super }
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end