ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,126 +0,0 @@
-require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro atomic_boolean_method_initialize
-  #
-  #   Creates a new `AtomicBoolean` with the given initial value.
-  #
-  #   @param [Boolean] initial the initial value
-
-  # @!macro atomic_boolean_method_value_get
-  #
-  #   Retrieves the current `Boolean` value.
-  #
-  #   @return [Boolean] the current value
-
-  # @!macro atomic_boolean_method_value_set
-  #
-  #   Explicitly sets the value.
-  #
-  #   @param [Boolean] value the new value to be set
-  #
-  #   @return [Boolean] the current value
-
-  # @!macro atomic_boolean_method_true_question
-  #
-  #   Is the current value `true`
-  #
-  #   @return [Boolean] true if the current value is `true`, else false
-
-  # @!macro atomic_boolean_method_false_question
-  #
-  #   Is the current value `false`
-  #
-  #   @return [Boolean] true if the current value is `false`, else false
-
-  # @!macro atomic_boolean_method_make_true
-  #
-  #   Explicitly sets the value to true.
-  #
-  #   @return [Boolean] true is value has changed, otherwise false
-
-  # @!macro atomic_boolean_method_make_false
-  #
-  #   Explicitly sets the value to false.
-  #
-  #   @return [Boolean] true is value has changed, otherwise false
-
-  ###################################################################
-
-  # @!macro atomic_boolean_public_api
-  #
-  #   @!method initialize(initial = false)
-  #     @!macro  atomic_boolean_method_initialize
-  #
-  #   @!method value
-  #     @!macro  atomic_boolean_method_value_get
-  #
-  #   @!method value=(value)
-  #     @!macro  atomic_boolean_method_value_set
-  #
-  #   @!method true?
-  #     @!macro  atomic_boolean_method_true_question
-  #
-  #   @!method false?
-  #     @!macro  atomic_boolean_method_false_question
-  #
-  #   @!method make_true
-  #     @!macro  atomic_boolean_method_make_true
-  #
-  #   @!method make_false
-  #     @!macro  atomic_boolean_method_make_false
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  AtomicBooleanImplementation = case
-                                when defined?(JavaAtomicBoolean)
-                                  JavaAtomicBoolean
-                                when defined?(CAtomicBoolean)
-                                  CAtomicBoolean
-                                else
-                                  MutexAtomicBoolean
-                                end
-  private_constant :AtomicBooleanImplementation
-
-  # @!macro atomic_boolean
-  #
-  #   A boolean value that can be updated atomically. Reads and writes to an atomic
-  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
-  #   briefly but no explicit locking is required.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   Performance:
-  #
-  #   ```
-  #   Testing with ruby 2.1.2
-  #   Testing with Concurrent::MutexAtomicBoolean...
-  #     2.790000   0.000000   2.790000 (  2.791454)
-  #   Testing with Concurrent::CAtomicBoolean...
-  #     0.740000   0.000000   0.740000 (  0.740206)
-  #
-  #   Testing with jruby 1.9.3
-  #   Testing with Concurrent::MutexAtomicBoolean...
-  #     5.240000   2.520000   7.760000 (  3.683000)
-  #   Testing with Concurrent::JavaAtomicBoolean...
-  #     3.340000   0.010000   3.350000 (  0.855000)
-  #   ```
-  #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
-  #
-  # @!macro atomic_boolean_public_api
-  class AtomicBoolean < AtomicBooleanImplementation
-    # @return [String] Short string representation.
-    def to_s
-      format '%s value:%s>', super[0..-2], value
-    end
-
-    alias_method :inspect, :to_s
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/atomic/count_down_latch.rb

@@ -1,100 +0,0 @@
-require 'concurrent/atomic/mutex_count_down_latch'
-require 'concurrent/atomic/java_count_down_latch'
-require 'concurrent/utility/engine'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro count_down_latch_method_initialize
-  #
-  #   Create a new `CountDownLatch` with the initial `count`.
-  #
-  #   @param [new] count the initial count
-  #
-  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
-
-  # @!macro count_down_latch_method_wait
-  #
-  #   Block on the latch until the counter reaches zero or until `timeout` is reached.
-  #
-  #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
-  #     to block indefinitely
-  #   @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
-
-  # @!macro count_down_latch_method_count_down
-  #
-  #   Signal the latch to decrement the counter. Will signal all blocked threads when
-  #   the `count` reaches zero.
-
-  # @!macro count_down_latch_method_count
-  #
-  #   The current value of the counter.
-  #
-  #   @return [Fixnum] the current value of the counter
-
-  ###################################################################
-
-  # @!macro count_down_latch_public_api
-  #
-  #   @!method initialize(count = 1)
-  #     @!macro count_down_latch_method_initialize
-  #
-  #   @!method wait(timeout = nil)
-  #     @!macro count_down_latch_method_wait
-  #
-  #   @!method count_down
-  #     @!macro count_down_latch_method_count_down
-  #
-  #   @!method count
-  #     @!macro count_down_latch_method_count
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  CountDownLatchImplementation = case
-                                 when Concurrent.on_jruby?
-                                   JavaCountDownLatch
-                                 else
-                                   MutexCountDownLatch
-                                 end
-  private_constant :CountDownLatchImplementation
-
-  # @!macro count_down_latch
-  #
-  #   A synchronization object that allows one thread to wait on multiple other threads.
-  #   The thread that will wait creates a `CountDownLatch` and sets the initial value
-  #   (normally equal to the number of other threads). The initiating thread passes the
-  #   latch to the other threads then waits for the other threads by calling the `#wait`
-  #   method. Each of the other threads calls `#count_down` when done with its work.
-  #   When the latch counter reaches zero the waiting thread is unblocked and continues
-  #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
-  #
-  # @!macro count_down_latch_public_api
-  # @example Waiter and Decrementer
-  #   latch = Concurrent::CountDownLatch.new(3)
-  #
-  #   waiter = Thread.new do
-  #     latch.wait()
-  #     puts ("Waiter released")
-  #   end
-  #
-  #   decrementer = Thread.new do
-  #     sleep(1)
-  #     latch.count_down
-  #     puts latch.count
-  #
-  #     sleep(1)
-  #     latch.count_down
-  #     puts latch.count
-  #
-  #     sleep(1)
-  #     latch.count_down
-  #     puts latch.count
-  #   end
-  #
-  #   [waiter, decrementer].each(&:join)
-  class CountDownLatch < CountDownLatchImplementation
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -1,161 +0,0 @@
-require 'thread'
-require 'concurrent/atomic/abstract_thread_local_var'
-
-module Concurrent
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RubyThreadLocalVar < AbstractThreadLocalVar
-
-    # Each thread has a (lazily initialized) array of thread-local variable values
-    # Each time a new thread-local var is created, we allocate an "index" for it
-    # For example, if the allocated index is 1, that means slot #1 in EVERY
-    #   thread's thread-local array will be used for the value of that TLV
-    #
-    # The good thing about using a per-THREAD structure to hold values, rather
-    #   than a per-TLV structure, is that no synchronization is needed when
-    #    reading and writing those values (since the structure is only ever
-    #    accessed by a single thread)
-    #
-    # Of course, when a TLV is GC'd, 1) we need to recover its index for use
-    #   by other new TLVs (otherwise the thread-local arrays could get bigger
-    #   and bigger with time), and 2) we need to null out all the references
-    #   held in the now-unused slots (both to avoid blocking GC of those objects,
-    #   and also to prevent "stale" values from being passed on to a new TLV
-    #   when the index is reused)
-    # Because we need to null out freed slots, we need to keep references to
-    #   ALL the thread-local arrays -- ARRAYS is for that
-    # But when a Thread is GC'd, we need to drop the reference to its thread-local
-    #   array, so we don't leak memory
-
-    # @!visibility private
-    FREE   = []
-    LOCK   = Mutex.new
-    ARRAYS = {} # used as a hash set
-    @@next = 0
-    private_constant :FREE, :LOCK, :ARRAYS
-
-    # @!macro thread_local_var_method_get
-    def value
-      if array = get_threadlocal_array
-        value = array[@index]
-        if value.nil?
-          default
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        default
-      end
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      me = Thread.current
-      # We could keep the thread-local arrays in a hash, keyed by Thread
-      # But why? That would require locking
-      # Using Ruby's built-in thread-local storage is faster
-      unless array = get_threadlocal_array(me)
-        array = set_threadlocal_array([], me)
-        LOCK.synchronize { ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
-      end
-      array[@index] = (value.nil? ? NULL : value)
-      value
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
-    end
-
-    # @!visibility private
-    def self.threadlocal_finalizer(index)
-      proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            FREE.push(index)
-            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-            # But that is natural! More threads means more storage is used per TLV
-            # So naturally more CPU time is required to free more storage
-            ARRAYS.each_value do |array|
-              array[index] = nil
-            end
-          end
-        end
-      end
-    end
-
-    # @!visibility private
-    def self.thread_finalizer(array)
-      proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            # The thread which used this thread-local array is now gone
-            # So don't hold onto a reference to the array (thus blocking GC)
-            ARRAYS.delete(array.object_id)
-          end
-        end
-      end
-    end
-
-    private
-
-    if Thread.instance_methods.include?(:thread_variable_get)
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread.thread_variable_get(:__threadlocal_array__)
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread.thread_variable_set(:__threadlocal_array__, array)
-      end
-
-    else
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread[:__threadlocal_array__]
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread[:__threadlocal_array__] = array
-      end
-    end
-
-    # This exists only for use in testing
-    # @!visibility private
-    def value_for(thread)
-      if array = get_threadlocal_array(thread)
-        value = array[@index]
-        if value.nil?
-          default_for(thread)
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        default_for(thread)
-      end
-    end
-
-    def default_for(thread)
-      if @default_block
-        raise "Cannot use default_for with default block"
-      else
-        @default
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/atomic/thread_local_var.rb

@@ -1,104 +0,0 @@
-require 'concurrent/atomic/ruby_thread_local_var'
-require 'concurrent/atomic/java_thread_local_var'
-require 'concurrent/utility/engine'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro thread_local_var_method_initialize
-  #
-  #   Creates a thread local variable.
-  #
-  #   @param [Object] default the default value when otherwise unset
-  #   @param [Proc] default_block Optional block that gets called to obtain the
-  #     default value for each thread
-
-  # @!macro thread_local_var_method_get
-  #
-  #   Returns the value in the current thread's copy of this thread-local variable.
-  #
-  #   @return [Object] the current value
-
-  # @!macro thread_local_var_method_set
-  #
-  #   Sets the current thread's copy of this thread-local variable to the specified value.
-  #
-  #   @param [Object] value the value to set
-  #   @return [Object] the new value
-
-  # @!macro thread_local_var_method_bind
-  #
-  #   Bind the given value to thread local storage during
-  #   execution of the given block.
-  #
-  #   @param [Object] value the value to bind
-  #   @yield the operation to be performed with the bound variable
-  #   @return [Object] the value
-
-
-  ###################################################################
-
-  # @!macro thread_local_var_public_api
-  #
-  #   @!method initialize(default = nil, &default_block)
-  #     @!macro thread_local_var_method_initialize
-  #
-  #   @!method value
-  #     @!macro thread_local_var_method_get
-  #
-  #   @!method value=(value)
-  #     @!macro thread_local_var_method_set
-  #
-  #   @!method bind(value, &block)
-  #     @!macro thread_local_var_method_bind
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  ThreadLocalVarImplementation = case
-                                 when Concurrent.on_jruby?
-                                   JavaThreadLocalVar
-                                 else
-                                   RubyThreadLocalVar
-                                 end
-  private_constant :ThreadLocalVarImplementation
-
-  # @!macro thread_local_var
-  #
-  #   A `ThreadLocalVar` is a variable where the value is different for each thread.
-  #   Each variable may have a default value, but when you modify the variable only
-  #   the current thread will ever see that change.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #     v.value #=> 14
-  #     v.value = 2
-  #     v.value #=> 2
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #
-  #     t1 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 1
-  #       v.value #=> 1
-  #     end
-  #
-  #     t2 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 2
-  #       v.value #=> 2
-  #     end
-  #
-  #     v.value #=> 14
-  #
-  #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
-  #
-  # @!macro thread_local_var_public_api
-  class ThreadLocalVar < ThreadLocalVarImplementation
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/collection/map/mri_map_backend.rb

@@ -1,66 +0,0 @@
-require 'thread'
-require 'concurrent/collection/map/non_concurrent_map_backend'
-
-module Concurrent
-
-  # @!visibility private
-  module Collection
-
-    # @!visibility private
-    class MriMapBackend < NonConcurrentMapBackend
-
-      def initialize(options = nil)
-        super(options)
-        @write_lock = Mutex.new
-      end
-
-      def []=(key, value)
-        @write_lock.synchronize { super }
-      end
-
-      def compute_if_absent(key)
-        if stored_value = _get(key) # fast non-blocking path for the most likely case
-          stored_value
-        else
-          @write_lock.synchronize { super }
-        end
-      end
-
-      def compute_if_present(key)
-        @write_lock.synchronize { super }
-      end
-
-      def compute(key)
-        @write_lock.synchronize { super }
-      end
-
-      def merge_pair(key, value)
-        @write_lock.synchronize { super }
-      end
-
-      def replace_pair(key, old_value, new_value)
-        @write_lock.synchronize { super }
-      end
-
-      def replace_if_exists(key, new_value)
-        @write_lock.synchronize { super }
-      end
-
-      def get_and_set(key, value)
-        @write_lock.synchronize { super }
-      end
-
-      def delete(key)
-        @write_lock.synchronize { super }
-      end
-
-      def delete_pair(key, value)
-        @write_lock.synchronize { super }
-      end
-
-      def clear
-        @write_lock.synchronize { super }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/concurrent-ruby-1.1.5/lib/concurrent/collection/non_concurrent_priority_queue.rb

@@ -1,143 +0,0 @@
-require 'concurrent/collection/java_non_concurrent_priority_queue'
-require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
-
-module Concurrent
-  module Collection
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    NonConcurrentPriorityQueueImplementation = case
-                                               when Concurrent.on_jruby?
-                                                 JavaNonConcurrentPriorityQueue
-                                               else
-                                                 RubyNonConcurrentPriorityQueue
-                                               end
-    private_constant :NonConcurrentPriorityQueueImplementation
-
-    # @!macro priority_queue
-    #
-    #   A queue collection in which the elements are sorted based on their
-    #   comparison (spaceship) operator `<=>`. Items are added to the queue
-    #   at a position relative to their priority. On removal the element
-    #   with the "highest" priority is removed. By default the sort order is
-    #   from highest to lowest, but a lowest-to-highest sort order can be
-    #   set on construction.
-    #
-    #   The API is based on the `Queue` class from the Ruby standard library.
-    #
-    #   The pure Ruby implementation, `RubyNonConcurrentPriorityQueue` uses a heap algorithm
-    #   stored in an array. The algorithm is based on the work of Robert Sedgewick
-    #   and Kevin Wayne.
-    #
-    #   The JRuby native implementation is a thin wrapper around the standard
-    #   library `java.util.NonConcurrentPriorityQueue`.
-    #
-    #   When running under JRuby the class `NonConcurrentPriorityQueue` extends `JavaNonConcurrentPriorityQueue`.
-    #   When running under all other interpreters it extends `RubyNonConcurrentPriorityQueue`.
-    #
-    #   @note This implementation is *not* thread safe.
-    #
-    #   @see http://en.wikipedia.org/wiki/Priority_queue
-    #   @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
-    #
-    #   @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
-    #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
-    #
-    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
-    #
-    # @!visibility private
-    class NonConcurrentPriorityQueue < NonConcurrentPriorityQueueImplementation
-
-      alias_method :has_priority?, :include?
-
-      alias_method :size, :length
-
-      alias_method :deq, :pop
-      alias_method :shift, :pop
-
-      alias_method :<<, :push
-      alias_method :enq, :push
-
-      # @!method initialize(opts = {})
-      #   @!macro priority_queue_method_initialize
-      #
-      #     Create a new priority queue with no items.
-      #
-      #     @param [Hash] opts the options for creating the queue
-      #     @option opts [Symbol] :order (:max) dictates the order in which items are
-      #       stored: from highest to lowest when `:max` or `:high`; from lowest to
-      #       highest when `:min` or `:low`
-
-      # @!method clear
-      #   @!macro priority_queue_method_clear
-      #
-      #     Removes all of the elements from this priority queue.
-
-      # @!method delete(item)
-      #   @!macro priority_queue_method_delete
-      #
-      #     Deletes all items from `self` that are equal to `item`.
-      #
-      #     @param [Object] item the item to be removed from the queue
-      #     @return [Object] true if the item is found else false
-
-      # @!method empty?
-      #   @!macro priority_queue_method_empty
-      #
-      #     Returns `true` if `self` contains no elements.
-      #
-      #     @return [Boolean] true if there are no items in the queue else false
-
-      # @!method include?(item)
-      #   @!macro priority_queue_method_include
-      #
-      #     Returns `true` if the given item is present in `self` (that is, if any
-      #     element == `item`), otherwise returns false.
-      #
-      #     @param [Object] item the item to search for
-      #
-      #     @return [Boolean] true if the item is found else false
-
-      # @!method length
-      #   @!macro priority_queue_method_length
-      #
-      #     The current length of the queue.
-      #
-      #     @return [Fixnum] the number of items in the queue
-
-      # @!method peek
-      #   @!macro priority_queue_method_peek
-      #
-      #     Retrieves, but does not remove, the head of this queue, or returns `nil`
-      #     if this queue is empty.
-      #
-      #     @return [Object] the head of the queue or `nil` when empty
-
-      # @!method pop
-      #   @!macro priority_queue_method_pop
-      #
-      #     Retrieves and removes the head of this queue, or returns `nil` if this
-      #     queue is empty.
-      #
-      #     @return [Object] the head of the queue or `nil` when empty
-
-      # @!method push(item)
-      #   @!macro priority_queue_method_push
-      #
-      #     Inserts the specified element into this priority queue.
-      #
-      #     @param [Object] item the item to insert onto the queue
-
-      # @!method self.from_list(list, opts = {})
-      #   @!macro priority_queue_method_from_list
-      #
-      #     Create a new priority queue from the given list.
-      #
-      #     @param [Enumerable] list the list to build the queue from
-      #     @param [Hash] opts the options for creating the queue
-      #
-      #     @return [NonConcurrentPriorityQueue] the newly created and populated queue
-    end
-  end
-end