ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/ivar.rb

@@ -1,207 +0,0 @@
-require 'concurrent/constants'
-require 'concurrent/errors'
-require 'concurrent/collection/copy_on_write_observer_set'
-require 'concurrent/concern/obligation'
-require 'concurrent/concern/observable'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # An `IVar` is like a future that you can assign. As a future is a value that
-  # is being computed that you can wait on, an `IVar` is a value that is waiting
-  # to be assigned, that you can wait on. `IVars` are single assignment and
-  # deterministic.
-  #
-  # Then, express futures as an asynchronous computation that assigns an `IVar`.
-  # The `IVar` becomes the primitive on which [futures](Future) and
-  # [dataflow](Dataflow) are built.
-  #
-  # An `IVar` is a single-element container that is normally created empty, and
-  # can only be set once. The I in `IVar` stands for immutable. Reading an
-  # `IVar` normally blocks until it is set. It is safe to set and read an `IVar`
-  # from different threads.
-  #
-  # If you want to have some parallel task set the value in an `IVar`, you want
-  # a `Future`. If you want to create a graph of parallel tasks all executed
-  # when the values they depend on are ready you want `dataflow`. `IVar` is
-  # generally a low-level primitive.
-  #
-  # ## Examples
-  #
-  # Create, set and get an `IVar`
-  #
-  # ```ruby
-  # ivar = Concurrent::IVar.new
-  # ivar.set 14
-  # ivar.value #=> 14
-  # ivar.set 2 # would now be an error
-  # ```
-  #
-  # ## See Also
-  #
-  # 1. For the theory: Arvind, R. Nikhil, and K. Pingali.
-  #    [I-Structures: Data structures for parallel computing](http://dl.acm.org/citation.cfm?id=69562).
-  #    In Proceedings of Workshop on Graph Reduction, 1986.
-  # 2. For recent application:
-  #    [DataDrivenFuture in Habanero Java from Rice](http://www.cs.rice.edu/~vs3/hjlib/doc/edu/rice/hj/api/HjDataDrivenFuture.html).
-  class IVar < Synchronization::LockableObject
-    include Concern::Obligation
-    include Concern::Observable
-
-    # Create a new `IVar` in the `:pending` state with the (optional) initial value.
-    #
-    # @param [Object] value the initial value
-    # @param [Hash] opts the options to create a message with
-    # @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 = NULL, opts = {}, &block)
-      if value != NULL && block_given?
-        raise ArgumentError.new('provide only a value or a block')
-      end
-      super(&nil)
-      synchronize { ns_initialize(value, opts, &block) }
-    end
-
-    # Add an observer on this object that will receive notification on update.
-    #
-    # Upon completion the `IVar` will notify all observers in a thread-safe way.
-    # The `func` method of the observer will be called with three arguments: the
-    # `Time` at which the `Future` completed the asynchronous operation, the
-    # final `value` (or `nil` on rejection), and the final `reason` (or `nil` on
-    # fulfillment).
-    #
-    # @param [Object] observer the object that will be notified of changes
-    # @param [Symbol] func symbol naming the method to call when this
-    #   `Observable` has changes`
-    def add_observer(observer = nil, func = :update, &block)
-      raise ArgumentError.new('cannot provide both an observer and a block') if observer && block
-      direct_notification = false
-
-      if block
-        observer = block
-        func = :call
-      end
-
-      synchronize do
-        if event.set?
-          direct_notification = true
-        else
-          observers.add_observer(observer, func)
-        end
-      end
-
-      observer.send(func, Time.now, self.value, reason) if direct_notification
-      observer
-    end
-
-    # @!macro ivar_set_method
-    #   Set the `IVar` to a value and wake or notify all threads waiting on it.
-    #
-    #   @!macro ivar_set_parameters_and_exceptions
-    #     @param [Object] value the value to store in the `IVar`
-    #     @yield A block operation to use for setting the value
-    #     @raise [ArgumentError] if both a value and a block are given
-    #     @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
-    #       been set or otherwise completed
-    #
-    #   @return [IVar] self
-    def set(value = NULL)
-      check_for_block_or_value!(block_given?, value)
-      raise MultipleAssignmentError unless compare_and_set_state(:processing, :pending)
-
-      begin
-        value = yield if block_given?
-        complete_without_notification(true, value, nil)
-      rescue => ex
-        complete_without_notification(false, nil, ex)
-      end
-
-      notify_observers(self.value, reason)
-      self
-    end
-
-    # @!macro ivar_fail_method
-    #   Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
-    #
-    #   @param [Object] reason for the failure
-    #   @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
-    #     been set or otherwise completed
-    #   @return [IVar] self
-    def fail(reason = StandardError.new)
-      complete(false, nil, reason)
-    end
-
-    # Attempt to set the `IVar` with the given value or block. Return a
-    # boolean indicating the success or failure of the set operation.
-    #
-    # @!macro ivar_set_parameters_and_exceptions
-    #
-    # @return [Boolean] true if the value was set else false
-    def try_set(value = NULL, &block)
-      set(value, &block)
-      true
-    rescue MultipleAssignmentError
-      false
-    end
-
-    protected
-
-    # @!visibility private
-    def ns_initialize(value, opts)
-      value = yield if block_given?
-      init_obligation
-      self.observers = Collection::CopyOnWriteObserverSet.new
-      set_deref_options(opts)
-
-      @state = :pending
-      if value != NULL
-        ns_complete_without_notification(true, value, nil)
-      end
-    end
-
-    # @!visibility private
-    def safe_execute(task, args = [])
-      if compare_and_set_state(:processing, :pending)
-        success, val, reason = SafeTaskExecutor.new(task, rescue_exception: true).execute(*@args)
-        complete(success, val, reason)
-        yield(success, val, reason) if block_given?
-      end
-    end
-
-    # @!visibility private
-    def complete(success, value, reason)
-      complete_without_notification(success, value, reason)
-      notify_observers(self.value, reason)
-      self
-    end
-
-    # @!visibility private
-    def complete_without_notification(success, value, reason)
-      synchronize { ns_complete_without_notification(success, value, reason) }
-      self
-    end
-
-    # @!visibility private
-    def notify_observers(value, reason)
-      observers.notify_and_delete_observers{ [Time.now, value, reason] }
-    end
-
-    # @!visibility private
-    def ns_complete_without_notification(success, value, reason)
-      raise MultipleAssignmentError if [:fulfilled, :rejected].include? @state
-      set_state(success, value, reason)
-      event.set
-    end
-
-    # @!visibility private
-    def check_for_block_or_value!(block_given, value) # :nodoc:
-      if (block_given && value != NULL) || (! block_given && value == NULL)
-        raise ArgumentError.new('must set with either a value or a block')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/concurrent-ruby-1.1.9/lib/concurrent-ruby/concurrent/map.rb

@@ -1,347 +0,0 @@
-require 'thread'
-require 'concurrent/constants'
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
-
-module Concurrent
-  # @!visibility private
-  module Collection
-
-    # @!visibility private
-    MapImplementation = case
-                        when Concurrent.on_jruby?
-                          # noinspection RubyResolve
-                          JRubyMapBackend
-                        when Concurrent.on_cruby?
-                          require 'concurrent/collection/map/mri_map_backend'
-                          MriMapBackend
-                        when Concurrent.on_truffleruby? && defined?(::TruffleRuby::ConcurrentMap)
-                          require 'concurrent/collection/map/truffleruby_map_backend'
-                          TruffleRubyMapBackend
-                        when Concurrent.on_truffleruby? || Concurrent.on_rbx?
-                          require 'concurrent/collection/map/atomic_reference_map_backend'
-                          AtomicReferenceMapBackend
-                        else
-                          warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'
-                          require 'concurrent/collection/map/synchronized_map_backend'
-                          SynchronizedMapBackend
-                        end
-  end
-
-  # `Concurrent::Map` is a hash-like object and should have much better performance
-  # characteristics, especially under high concurrency, than `Concurrent::Hash`.
-  # However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
-  # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
-  # does. For most uses it should do fine though, and we recommend you consider
-  # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
-  class Map < Collection::MapImplementation
-
-    # @!macro map.atomic_method
-    #   This method is atomic.
-
-    # @!macro map.atomic_method_with_block
-    #   This method is atomic.
-    #   @note Atomic methods taking a block do not allow the `self` instance
-    #     to be used within the block. Doing so will cause a deadlock.
-
-    # @!method compute_if_absent(key)
-    #   Compute and store new value for key if the key is absent.
-    #   @param [Object] key
-    #   @yield new value
-    #   @yieldreturn [Object] new value
-    #   @return [Object] new value or current value
-    #   @!macro map.atomic_method_with_block
-
-    # @!method compute_if_present(key)
-    #   Compute and store new value for key if the key is present.
-    #   @param [Object] key
-    #   @yield new value
-    #   @yieldparam old_value [Object]
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method compute(key)
-    #   Compute and store new value for key.
-    #   @param [Object] key
-    #   @yield compute new value from old one
-    #   @yieldparam old_value [Object, nil] old_value, or nil when key is absent
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method merge_pair(key, value)
-    #   If the key is absent, the value is stored, otherwise new value is
-    #   computed with a block.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @yield compute new value from old one
-    #   @yieldparam old_value [Object] old value
-    #   @yieldreturn [Object, nil] new value, when nil the key is removed
-    #   @return [Object, nil] new value or nil
-    #   @!macro map.atomic_method_with_block
-
-    # @!method replace_pair(key, old_value, new_value)
-    #   Replaces old_value with new_value if key exists and current value
-    #   matches old_value
-    #   @param [Object] key
-    #   @param [Object] old_value
-    #   @param [Object] new_value
-    #   @return [true, false] true if replaced
-    #   @!macro map.atomic_method
-
-    # @!method replace_if_exists(key, new_value)
-    #   Replaces current value with new_value if key exists
-    #   @param [Object] key
-    #   @param [Object] new_value
-    #   @return [Object, nil] old value or nil
-    #   @!macro map.atomic_method
-
-    # @!method get_and_set(key, value)
-    #   Get the current value under key and set new value.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @return [Object, nil] old value or nil when the key was absent
-    #   @!macro map.atomic_method
-
-    # @!method delete(key)
-    #   Delete key and its value.
-    #   @param [Object] key
-    #   @return [Object, nil] old value or nil when the key was absent
-    #   @!macro map.atomic_method
-
-    # @!method delete_pair(key, value)
-    #   Delete pair and its value if current value equals the provided value.
-    #   @param [Object] key
-    #   @param [Object] value
-    #   @return [true, false] true if deleted
-    #   @!macro map.atomic_method
-
-    #
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
-
-      super(options)
-      @default_proc = block
-    end
-
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-        # would be returned)
-        # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
-      end
-    end
-
-    # Set a value with key
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object] the new value
-    def []=(key, value)
-      super
-    end
-
-    alias_method :get, :[]
-    alias_method :put, :[]=
-
-    # Get a value with key, or default_value when key is absent,
-    # or fail when no default_value is given.
-    # @param [Object] key
-    # @param [Object] default_value
-    # @yield default value for a key
-    # @yieldparam key [Object]
-    # @yieldreturn [Object] default value
-    # @return [Object] the value or default value
-    # @raise [KeyError] when key is missing and no default_value is provided
-    # @!macro map_method_not_atomic
-    #   @note The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
-    #     to be use as a concurrency primitive with strong happens-before
-    #     guarantees. It is not intended to be used as a high-level abstraction
-    #     supporting complex operations. All read and write operations are
-    #     thread safe, but no guarantees are made regarding race conditions
-    #     between the fetch operation and yielding to the block. Additionally,
-    #     this method does not support recursion. This is due to internal
-    #     constraints that are very unlikely to change in the near future.
-    def fetch(key, default_value = NULL)
-      if NULL != (value = get_or_default(key, NULL))
-        value
-      elsif block_given?
-        yield key
-      elsif NULL != default_value
-        default_value
-      else
-        raise_fetch_no_key
-      end
-    end
-
-    # Fetch value with key, or store default value when key is absent,
-    # or fail when no default_value is given. This is a two step operation,
-    # therefore not atomic. The store can overwrite other concurrently
-    # stored value.
-    # @param [Object] key
-    # @param [Object] default_value
-    # @yield default value for a key
-    # @yieldparam key [Object]
-    # @yieldreturn [Object] default value
-    # @return [Object] the value or default value
-    # @!macro map.atomic_method_with_block
-    def fetch_or_store(key, default_value = NULL)
-      fetch(key) do
-        put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
-      end
-    end
-
-    # Insert value into map with key if key is absent in one atomic step.
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object, nil] the previous value when key was present or nil when there was no key
-    def put_if_absent(key, value)
-      computed = false
-      result   = compute_if_absent(key) do
-        computed = true
-        value
-      end
-      computed ? nil : result
-    end unless method_defined?(:put_if_absent)
-
-    # Is the value stored in the map. Iterates over all values.
-    # @param [Object] value
-    # @return [true, false]
-    def value?(value)
-      each_value do |v|
-        return true if value.equal?(v)
-      end
-      false
-    end
-
-    # All keys
-    # @return [::Array<Object>] keys
-    def keys
-      arr = []
-      each_pair { |k, v| arr << k }
-      arr
-    end unless method_defined?(:keys)
-
-    # All values
-    # @return [::Array<Object>] values
-    def values
-      arr = []
-      each_pair { |k, v| arr << v }
-      arr
-    end unless method_defined?(:values)
-
-    # Iterates over each key.
-    # @yield for each key in the map
-    # @yieldparam key [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_key
-      each_pair { |k, v| yield k }
-    end unless method_defined?(:each_key)
-
-    # Iterates over each value.
-    # @yield for each value in the map
-    # @yieldparam value [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_value
-      each_pair { |k, v| yield v }
-    end unless method_defined?(:each_value)
-
-    # Iterates over each key value pair.
-    # @yield for each key value pair in the map
-    # @yieldparam key [Object]
-    # @yieldparam value [Object]
-    # @return [self]
-    # @!macro map.atomic_method_with_block
-    def each_pair
-      return enum_for :each_pair unless block_given?
-      super
-    end
-
-    alias_method :each, :each_pair unless method_defined?(:each)
-
-    # Find key of a value.
-    # @param [Object] value
-    # @return [Object, nil] key or nil when not found
-    def key(value)
-      each_pair { |k, v| return k if v == value }
-      nil
-    end unless method_defined?(:key)
-    alias_method :index, :key if RUBY_VERSION < '1.9'
-
-    # Is map empty?
-    # @return [true, false]
-    def empty?
-      each_pair { |k, v| return false }
-      true
-    end unless method_defined?(:empty?)
-
-    # The size of map.
-    # @return [Integer] size
-    def size
-      count = 0
-      each_pair { |k, v| count += 1 }
-      count
-    end unless method_defined?(:size)
-
-    # @!visibility private
-    def marshal_dump
-      raise TypeError, "can't dump hash with default proc" if @default_proc
-      h = {}
-      each_pair { |k, v| h[k] = v }
-      h
-    end
-
-    # @!visibility private
-    def marshal_load(hash)
-      initialize
-      populate_from(hash)
-    end
-
-    undef :freeze
-
-    # @!visibility private
-    def inspect
-      format '%s entries=%d default_proc=%s>', to_s[0..-2], size.to_s, @default_proc.inspect
-    end
-
-    private
-
-    def raise_fetch_no_key
-      raise KeyError, 'key not found'
-    end
-
-    def initialize_copy(other)
-      super
-      populate_from(other)
-    end
-
-    def populate_from(hash)
-      hash.each_pair { |k, v| self[k] = v }
-      self
-    end
-
-    def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Integer) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Integer"
-      end
-      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
-        raise ArgumentError, ":load_factor must be a number between 0 and 1"
-      end
-    end
-  end
-end