concurrent-ruby 1.0.5 → 1.1.1

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