concurrent-ruby-edge 0.3.1 → 0.4.0.pre1

data/lib-edge/concurrent/lazy_register.rb

@@ -0,0 +1,83 @@
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/delay'
+
+module Concurrent
+
+  # Hash-like collection that store lazy evaluated values.
+  #
+  # @!macro warn.edge
+  #
+  # @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)>
+  #
+  class LazyRegister < Synchronization::Object
+
+    attr_atomic(:data)
+    private :data, :data=, :swap_data, :compare_and_set_data, :update_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 → lib-edge}/concurrent-edge.rb

@@ -3,15 +3,11 @@ require 'concurrent'
 require 'concurrent/actor'
 require 'concurrent/agent'
 require 'concurrent/channel'
-require 'concurrent/exchanger'
 require 'concurrent/lazy_register'
 
-require 'concurrent/edge/atomic_markable_reference'
 require 'concurrent/edge/lock_free_linked_set'
 require 'concurrent/edge/lock_free_queue'
-require 'concurrent/edge/lock_free_stack'
 
-require 'concurrent/edge/promises'
 require 'concurrent/edge/cancellation'
 require 'concurrent/edge/throttle'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0.pre1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-26 00:00:00.000000000 Z
+date: 2018-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.1.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.1.0.pre1
 description: |
   These 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
@@ -36,66 +36,68 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
-- LICENSE.txt
+- LICENSE.md
+- CHANGELOG.md
 files:
-- LICENSE.txt
+- CHANGELOG.md
+- LICENSE.md
 - README.md
-- lib/concurrent-edge.rb
-- lib/concurrent/actor.rb
-- lib/concurrent/actor/behaviour.rb
-- lib/concurrent/actor/behaviour/abstract.rb
-- lib/concurrent/actor/behaviour/awaits.rb
-- lib/concurrent/actor/behaviour/buffer.rb
-- lib/concurrent/actor/behaviour/errors_on_unknown_message.rb
-- lib/concurrent/actor/behaviour/executes_context.rb
-- lib/concurrent/actor/behaviour/linking.rb
-- lib/concurrent/actor/behaviour/pausing.rb
-- lib/concurrent/actor/behaviour/removes_child.rb
-- lib/concurrent/actor/behaviour/sets_results.rb
-- lib/concurrent/actor/behaviour/supervising.rb
-- lib/concurrent/actor/behaviour/termination.rb
-- lib/concurrent/actor/context.rb
-- lib/concurrent/actor/core.rb
-- lib/concurrent/actor/default_dead_letter_handler.rb
-- lib/concurrent/actor/envelope.rb
-- lib/concurrent/actor/errors.rb
-- lib/concurrent/actor/internal_delegations.rb
-- lib/concurrent/actor/public_delegations.rb
-- lib/concurrent/actor/reference.rb
-- lib/concurrent/actor/root.rb
-- lib/concurrent/actor/type_check.rb
-- lib/concurrent/actor/utils.rb
-- lib/concurrent/actor/utils/ad_hoc.rb
-- lib/concurrent/actor/utils/balancer.rb
-- lib/concurrent/actor/utils/broadcast.rb
-- lib/concurrent/actor/utils/pool.rb
-- lib/concurrent/channel.rb
-- lib/concurrent/channel/buffer.rb
-- lib/concurrent/channel/buffer/base.rb
-- lib/concurrent/channel/buffer/buffered.rb
-- lib/concurrent/channel/buffer/dropping.rb
-- lib/concurrent/channel/buffer/sliding.rb
-- lib/concurrent/channel/buffer/ticker.rb
-- lib/concurrent/channel/buffer/timer.rb
-- lib/concurrent/channel/buffer/unbuffered.rb
-- lib/concurrent/channel/selector.rb
-- lib/concurrent/channel/selector/after_clause.rb
-- lib/concurrent/channel/selector/default_clause.rb
-- lib/concurrent/channel/selector/error_clause.rb
-- lib/concurrent/channel/selector/put_clause.rb
-- lib/concurrent/channel/selector/take_clause.rb
-- lib/concurrent/channel/tick.rb
-- lib/concurrent/edge/atomic_markable_reference.rb
-- lib/concurrent/edge/cancellation.rb
-- lib/concurrent/edge/lock_free_linked_set.rb
-- lib/concurrent/edge/lock_free_linked_set/node.rb
-- lib/concurrent/edge/lock_free_linked_set/window.rb
-- lib/concurrent/edge/lock_free_queue.rb
-- lib/concurrent/edge/lock_free_stack.rb
-- lib/concurrent/edge/old_channel_integration.rb
-- lib/concurrent/edge/processing_actor.rb
-- lib/concurrent/edge/promises.rb
-- lib/concurrent/edge/throttle.rb
+- lib-edge/concurrent-edge.rb
+- lib-edge/concurrent/actor.rb
+- lib-edge/concurrent/actor/behaviour.rb
+- lib-edge/concurrent/actor/behaviour/abstract.rb
+- lib-edge/concurrent/actor/behaviour/awaits.rb
+- lib-edge/concurrent/actor/behaviour/buffer.rb
+- lib-edge/concurrent/actor/behaviour/errors_on_unknown_message.rb
+- lib-edge/concurrent/actor/behaviour/executes_context.rb
+- lib-edge/concurrent/actor/behaviour/linking.rb
+- lib-edge/concurrent/actor/behaviour/pausing.rb
+- lib-edge/concurrent/actor/behaviour/removes_child.rb
+- lib-edge/concurrent/actor/behaviour/sets_results.rb
+- lib-edge/concurrent/actor/behaviour/supervising.rb
+- lib-edge/concurrent/actor/behaviour/termination.rb
+- lib-edge/concurrent/actor/context.rb
+- lib-edge/concurrent/actor/core.rb
+- lib-edge/concurrent/actor/default_dead_letter_handler.rb
+- lib-edge/concurrent/actor/envelope.rb
+- lib-edge/concurrent/actor/errors.rb
+- lib-edge/concurrent/actor/internal_delegations.rb
+- lib-edge/concurrent/actor/public_delegations.rb
+- lib-edge/concurrent/actor/reference.rb
+- lib-edge/concurrent/actor/root.rb
+- lib-edge/concurrent/actor/type_check.rb
+- lib-edge/concurrent/actor/utils.rb
+- lib-edge/concurrent/actor/utils/ad_hoc.rb
+- lib-edge/concurrent/actor/utils/balancer.rb
+- lib-edge/concurrent/actor/utils/broadcast.rb
+- lib-edge/concurrent/actor/utils/pool.rb
+- lib-edge/concurrent/channel.rb
+- lib-edge/concurrent/channel/buffer.rb
+- lib-edge/concurrent/channel/buffer/base.rb
+- lib-edge/concurrent/channel/buffer/buffered.rb
+- lib-edge/concurrent/channel/buffer/dropping.rb
+- lib-edge/concurrent/channel/buffer/sliding.rb
+- lib-edge/concurrent/channel/buffer/ticker.rb
+- lib-edge/concurrent/channel/buffer/timer.rb
+- lib-edge/concurrent/channel/buffer/unbuffered.rb
+- lib-edge/concurrent/channel/selector.rb
+- lib-edge/concurrent/channel/selector/after_clause.rb
+- lib-edge/concurrent/channel/selector/default_clause.rb
+- lib-edge/concurrent/channel/selector/error_clause.rb
+- lib-edge/concurrent/channel/selector/put_clause.rb
+- lib-edge/concurrent/channel/selector/take_clause.rb
+- lib-edge/concurrent/channel/tick.rb
+- lib-edge/concurrent/edge.rb
+- lib-edge/concurrent/edge/cancellation.rb
+- lib-edge/concurrent/edge/lock_free_linked_set.rb
+- lib-edge/concurrent/edge/lock_free_linked_set/node.rb
+- lib-edge/concurrent/edge/lock_free_linked_set/window.rb
+- lib-edge/concurrent/edge/lock_free_queue.rb
+- lib-edge/concurrent/edge/old_channel_integration.rb
+- lib-edge/concurrent/edge/processing_actor.rb
+- lib-edge/concurrent/edge/promises.rb
+- lib-edge/concurrent/edge/throttle.rb
+- lib-edge/concurrent/lazy_register.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
@@ -103,22 +105,21 @@ metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
-- lib
+- lib-edge
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Edge features and additions to the concurrent-ruby gem.
 test_files: []
-has_rdoc: 

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -1,184 +0,0 @@
-module Concurrent
-  module Edge
-
-    # @!macro [attach] atomic_markable_reference
-    #
-    #   An atomic reference which maintains an object reference along with a mark bit
-    #   that can be updated atomically.
-    #
-    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html
-    #     java.util.concurrent.atomic.AtomicMarkableReference
-    class AtomicMarkableReference < ::Concurrent::Synchronization::Object
-
-      private(*attr_atomic(:reference))
-
-      # @!macro [attach] atomic_markable_reference_method_initialize
-      def initialize(value = nil, mark = false)
-        super()
-        self.reference = ImmutableArray[value, mark]
-      end
-
-      # @!macro [attach] atomic_markable_reference_method_compare_and_set
-      #
-      #   Atomically sets the value and mark to the given updated value and
-      #   mark given both:
-      #     - the current value == the expected value &&
-      #     - the current mark == the expected mark
-      #
-      #   @param [Object] expected_val the expected value
-      #   @param [Object] new_val the new value
-      #   @param [Boolean] expected_mark the expected mark
-      #   @param [Boolean] new_mark the new mark
-      #
-      #   @return [Boolean] `true` if successful. A `false` return indicates
-      #   that the actual value was not equal to the expected value or the
-      #   actual mark was not equal to the expected mark
-      def compare_and_set(expected_val, new_val, expected_mark, new_mark)
-        # Memoize a valid reference to the current AtomicReference for
-        # later comparison.
-        current = reference
-        curr_val, curr_mark = current
-
-        # Ensure that that the expected marks match.
-        return false unless expected_mark == curr_mark
-
-        if expected_val.is_a? Numeric
-          # If the object is a numeric, we need to ensure we are comparing
-          # the numerical values
-          return false unless expected_val == curr_val
-        else
-          # Otherwise, we need to ensure we are comparing the object identity.
-          # Theoretically, this could be incorrect if a user monkey-patched
-          # `Object#equal?`, but they should know that they are playing with
-          # fire at that point.
-          return false unless expected_val.equal? curr_val
-        end
-
-        prospect = ImmutableArray[new_val, new_mark]
-
-        compare_and_set_reference current, prospect
-      end
-      alias_method :compare_and_swap, :compare_and_set
-
-      # @!macro [attach] atomic_markable_reference_method_get
-      #
-      #   Gets the current reference and marked values.
-      #
-      #   @return [ImmutableArray] the current reference and marked values
-      def get
-        reference
-      end
-
-      # @!macro [attach] atomic_markable_reference_method_value
-      #
-      #   Gets the current value of the reference
-      #
-      #   @return [Object] the current value of the reference
-      def value
-        reference[0]
-      end
-
-      # @!macro [attach] atomic_markable_reference_method_mark
-      #
-      #   Gets the current marked value
-      #
-      #   @return [Boolean] the current marked value
-      def mark
-        reference[1]
-      end
-      alias_method :marked?, :mark
-
-      # @!macro [attach] atomic_markable_reference_method_set
-      #
-      #   _Unconditionally_ sets to the given value of both the reference and
-      #   the mark.
-      #
-      #   @param [Object] new_val the new value
-      #   @param [Boolean] new_mark the new mark
-      #
-      #   @return [ImmutableArray] both the new value and the new mark
-      def set(new_val, new_mark)
-        self.reference = ImmutableArray[new_val, new_mark]
-      end
-
-      # @!macro [attach] atomic_markable_reference_method_update
-      #
-      # Pass the current value and marked state to the given block, replacing it
-      # with the block's results. May retry if the value changes during the
-      # block's execution.
-      #
-      # @yield [Object] Calculate a new value and marked state for the atomic
-      #   reference using given (old) value and (old) marked
-      # @yieldparam [Object] old_val the starting value of the atomic reference
-      # @yieldparam [Boolean] old_mark the starting state of marked
-      #
-      # @return [ImmutableArray] the new value and new mark
-      def update
-        loop do
-          old_val, old_mark = reference
-          new_val, new_mark = yield old_val, old_mark
-
-          if compare_and_set old_val, new_val, old_mark, new_mark
-            return ImmutableArray[new_val, new_mark]
-          end
-        end
-      end
-
-      # @!macro [attach] atomic_markable_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 and marked state for the atomic
-      #   reference using given (old) value and (old) marked
-      # @yieldparam [Object] old_val the starting value of the atomic reference
-      # @yieldparam [Boolean] old_mark the starting state of marked
-      #
-      # @return [ImmutableArray] the new value and marked state
-      #
-      # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-      def try_update!
-        old_val, old_mark = reference
-        new_val, new_mark = yield old_val, old_mark
-
-        unless compare_and_set old_val, new_val, old_mark, new_mark
-          fail ::Concurrent::ConcurrentUpdateError,
-               'AtomicMarkableReference: Update failed due to race condition.',
-               'Note: If you would like to guarantee an update, please use ' \
-               'the `AtomicMarkableReference#update` method.'
-        end
-
-        ImmutableArray[new_val, new_mark]
-      end
-
-      # @!macro [attach] atomic_markable_reference_method_try_update
-      #
-      # Pass the current value to the given block, replacing it with the
-      # block's result. Simply return nil if update fails.
-      #
-      # @yield [Object] Calculate a new value and marked state for the atomic
-      #   reference using given (old) value and (old) marked
-      # @yieldparam [Object] old_val the starting value of the atomic reference
-      # @yieldparam [Boolean] old_mark the starting state of marked
-      #
-      # @return [ImmutableArray] the new value and marked state, or nil if
-      # the update failed
-      def try_update
-        old_val, old_mark = reference
-        new_val, new_mark = yield old_val, old_mark
-
-        return unless compare_and_set old_val, new_val, old_mark, new_mark
-
-        ImmutableArray[new_val, new_mark]
-      end
-
-      # Internal/private ImmutableArray for representing pairs
-      class ImmutableArray < ::Array
-        def self.new(*args)
-          super(*args).freeze
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/edge/lock_free_stack.rb

@@ -1,126 +0,0 @@
-module Concurrent
-
-  # @!visibility private
-  class LockFreeStack < Synchronization::Object
-
-    safe_initialization!
-
-    class Node
-      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
-
-      attr_reader :value, :next_node
-      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
-      attr_writer :value
-
-      def initialize(value, next_node)
-        @value     = value
-        @next_node = next_node
-      end
-
-      singleton_class.send :alias_method, :[], :new
-    end
-
-    class Empty < Node
-      def next_node
-        self
-      end
-    end
-
-    EMPTY = Empty[nil, nil]
-
-    private(*attr_atomic(:head))
-
-    def self.of1(value)
-      new Node[value, EMPTY]
-    end
-
-    def self.of2(value1, value2)
-      new Node[value1, Node[value2, EMPTY]]
-    end
-
-    def initialize(head = EMPTY)
-      super()
-      self.head = head
-    end
-
-    def empty?(head = self.head)
-      head.equal? EMPTY
-    end
-
-    def compare_and_push(head, value)
-      compare_and_set_head head, Node[value, head]
-    end
-
-    def push(value)
-      while true
-        current_head = head
-        return self if compare_and_set_head current_head, Node[value, current_head]
-      end
-    end
-
-    def peek
-      head
-    end
-
-    def compare_and_pop(head)
-      compare_and_set_head head, head.next_node
-    end
-
-    def pop
-      while true
-        current_head = head
-        return current_head.value if compare_and_set_head current_head, current_head.next_node
-      end
-    end
-
-    def compare_and_clear(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    include Enumerable
-
-    def each(head = nil)
-      return to_enum(:each, head) unless block_given?
-      it = head || peek
-      until it.equal?(EMPTY)
-        yield it.value
-        it = it.next_node
-      end
-      self
-    end
-
-    def clear
-      while true
-        current_head = head
-        return false if current_head == EMPTY
-        return true if compare_and_set_head current_head, EMPTY
-      end
-    end
-
-    def clear_if(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    def replace_if(head, new_head)
-      compare_and_set_head head, new_head
-    end
-
-    def clear_each(&block)
-      while true
-        current_head = head
-        return self if current_head == EMPTY
-        if compare_and_set_head current_head, EMPTY
-          each current_head, &block
-          return self
-        end
-      end
-    end
-
-    # @return [String] Short string representation.
-    def to_s
-      format '<#%s:0x%x %s>', self.class, object_id << 1, to_a.to_s
-    end
-
-    alias_method :inspect, :to_s
-  end
-end