pangea-core 0.1.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb

@@ -0,0 +1,127 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/atomic/mutex_atomic_boolean'
+
+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 if value has changed, otherwise false
+
+  # @!macro atomic_boolean_method_make_false
+  #
+  #   Explicitly sets the value to false.
+  #
+  #   @return [Boolean] true if 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 Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
+                                  CAtomicBoolean
+                                when Concurrent.on_jruby?
+                                  JavaAtomicBoolean
+                                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/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb

@@ -0,0 +1,144 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/atomic/mutex_atomic_fixnum'
+
+module Concurrent
+
+  ###################################################################
+
+  # @!macro atomic_fixnum_method_initialize
+  #
+  #   Creates a new `AtomicFixnum` with the given initial value.
+  #
+  #   @param [Fixnum] initial the initial value
+  #   @raise [ArgumentError] if the initial value is not a `Fixnum`
+
+  # @!macro atomic_fixnum_method_value_get
+  #
+  #   Retrieves the current `Fixnum` value.
+  #
+  #   @return [Fixnum] the current value
+
+  # @!macro atomic_fixnum_method_value_set
+  #
+  #   Explicitly sets the value.
+  #
+  #   @param [Fixnum] value the new value to be set
+  #
+  #   @return [Fixnum] the current value
+  #
+  #   @raise [ArgumentError] if the new value is not a `Fixnum`
+
+  # @!macro atomic_fixnum_method_increment
+  #
+  #   Increases the current value by the given amount (defaults to 1).
+  #
+  #   @param [Fixnum] delta the amount by which to increase the current value
+  #
+  #   @return [Fixnum] the current value after incrementation
+
+  # @!macro atomic_fixnum_method_decrement
+  #
+  #   Decreases the current value by the given amount (defaults to 1).
+  #
+  #   @param [Fixnum] delta the amount by which to decrease the current value
+  #
+  #   @return [Fixnum] the current value after decrementation
+
+  # @!macro atomic_fixnum_method_compare_and_set
+  #
+  #   Atomically sets the value to the given updated value if the current
+  #   value == the expected value.
+  #
+  #   @param [Fixnum] expect the expected value
+  #   @param [Fixnum] update the new value
+  #
+  #   @return [Boolean] true if the value was updated else false
+
+  # @!macro atomic_fixnum_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
+
+  ###################################################################
+
+  # @!macro atomic_fixnum_public_api
+  #
+  #   @!method initialize(initial = 0)
+  #     @!macro atomic_fixnum_method_initialize
+  #
+  #   @!method value
+  #     @!macro atomic_fixnum_method_value_get
+  #
+  #   @!method value=(value)
+  #     @!macro atomic_fixnum_method_value_set
+  #
+  #   @!method increment(delta = 1)
+  #     @!macro atomic_fixnum_method_increment
+  #
+  #   @!method decrement(delta = 1)
+  #     @!macro atomic_fixnum_method_decrement
+  #
+  #   @!method compare_and_set(expect, update)
+  #     @!macro atomic_fixnum_method_compare_and_set
+  #
+  #   @!method update
+  #     @!macro atomic_fixnum_method_update
+
+  ###################################################################
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  AtomicFixnumImplementation = case
+                               when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
+                                 CAtomicFixnum
+                               when Concurrent.on_jruby?
+                                 JavaAtomicFixnum
+                               else
+                                 MutexAtomicFixnum
+                               end
+  private_constant :AtomicFixnumImplementation
+
+  # @!macro atomic_fixnum
+  #
+  #   A numeric value that can be updated atomically. Reads and writes to an atomic
+  #   fixnum 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::MutexAtomicFixnum...
+  #     3.130000   0.000000   3.130000 (  3.136505)
+  #   Testing with Concurrent::CAtomicFixnum...
+  #     0.790000   0.000000   0.790000 (  0.785550)
+  #
+  #   Testing with jruby 1.9.3
+  #   Testing with Concurrent::MutexAtomicFixnum...
+  #     5.460000   2.460000   7.920000 (  3.715000)
+  #   Testing with Concurrent::JavaAtomicFixnum...
+  #     4.520000   0.030000   4.550000 (  1.187000)
+  #   ```
+  #
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+  #
+  # @!macro atomic_fixnum_public_api
+  class AtomicFixnum < AtomicFixnumImplementation
+    # @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/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb

@@ -0,0 +1,167 @@
+require 'concurrent/errors'
+require 'concurrent/synchronization/object'
+
+module Concurrent
+  # 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
+
+    attr_atomic(:reference)
+    private :reference, :reference=, :swap_reference, :compare_and_set_reference, :update_reference
+
+    def initialize(value = nil, mark = false)
+      super()
+      self.reference = immutable_array(value, mark)
+    end
+
+    # 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 = immutable_array(new_val, new_mark)
+
+      compare_and_set_reference current, prospect
+    end
+
+    alias_method :compare_and_swap, :compare_and_set
+
+    # Gets the current reference and marked values.
+    #
+    # @return [Array] the current reference and marked values
+    def get
+      reference
+    end
+
+    # Gets the current value of the reference
+    #
+    # @return [Object] the current value of the reference
+    def value
+      reference[0]
+    end
+
+    # Gets the current marked value
+    #
+    # @return [Boolean] the current marked value
+    def mark
+      reference[1]
+    end
+
+    alias_method :marked?, :mark
+
+    # _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 [Array] both the new value and the new mark
+    def set(new_val, new_mark)
+      self.reference = immutable_array(new_val, new_mark)
+    end
+
+    # 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 [Array] 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 immutable_array(new_val, new_mark)
+        end
+      end
+    end
+
+    # 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 [Array] 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
+
+      immutable_array(new_val, new_mark)
+    end
+
+    # 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 [Array] 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
+
+      immutable_array(new_val, new_mark)
+    end
+
+    private
+
+    def immutable_array(*args)
+      args.freeze
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb

@@ -0,0 +1,135 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/atomic_reference/atomic_direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+require 'concurrent/atomic_reference/mutex_atomic'
+
+# Shim for TruffleRuby::AtomicReference
+if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
+  # @!visibility private
+  module TruffleRuby
+    AtomicReference = Truffle::AtomicReference
+  end
+end
+
+module Concurrent
+
+  # @!macro internal_implementation_note
+  AtomicReferenceImplementation = case
+                                  when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
+                                    # @!visibility private
+                                    # @!macro internal_implementation_note
+                                    class CAtomicReference
+                                      include AtomicDirectUpdate
+                                      include AtomicNumericCompareAndSetWrapper
+                                      alias_method :compare_and_swap, :compare_and_set
+                                    end
+                                    CAtomicReference
+                                  when Concurrent.on_jruby?
+                                    # @!visibility private
+                                    # @!macro internal_implementation_note
+                                    class JavaAtomicReference
+                                      include AtomicDirectUpdate
+                                    end
+                                    JavaAtomicReference
+                                  when Concurrent.on_truffleruby?
+                                    class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
+                                      include AtomicDirectUpdate
+                                      alias_method :value, :get
+                                      alias_method :value=, :set
+                                      alias_method :compare_and_swap, :compare_and_set
+                                      alias_method :swap, :get_and_set
+                                    end
+                                    TruffleRubyAtomicReference
+                                  else
+                                    MutexAtomicReference
+                                  end
+  private_constant :AtomicReferenceImplementation
+
+  # An object reference that may be updated atomically. All read and write
+  # operations have java volatile semantic.
+  #
+  # @!macro thread_safe_variable_comparison
+  #
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+  #
+  # @!method initialize(value = nil)
+  #   @!macro atomic_reference_method_initialize
+  #     @param [Object] value The initial value.
+  #
+  # @!method get
+  #   @!macro atomic_reference_method_get
+  #     Gets the current value.
+  #     @return [Object] the current value
+  #
+  # @!method set(new_value)
+  #   @!macro atomic_reference_method_set
+  #     Sets to the given value.
+  #     @param [Object] new_value the new value
+  #     @return [Object] the new value
+  #
+  # @!method get_and_set(new_value)
+  #   @!macro atomic_reference_method_get_and_set
+  #     Atomically sets to the given value and returns the old value.
+  #     @param [Object] new_value the new value
+  #     @return [Object] the old value
+  #
+  # @!method compare_and_set(old_value, new_value)
+  #   @!macro atomic_reference_method_compare_and_set
+  #
+  #     Atomically sets the value to the given updated value if
+  #     the current value == the expected value.
+  #
+  #     @param [Object] old_value the expected value
+  #     @param [Object] new_value the new value
+  #
+  #     @return [Boolean] `true` if successful. A `false` return indicates
+  #     that the actual value was not equal to the expected value.
+  #
+  # @!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
+  #
+  # @!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
+  #
+  # @!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
+  class AtomicReference < AtomicReferenceImplementation
+
+    # @return [String] Short string representation.
+    def to_s
+      format '%s value:%s>', super[0..-2], get
+    end
+
+    alias_method :inspect, :to_s
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.6/lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb

@@ -0,0 +1,100 @@
+require 'concurrent/utility/engine'
+require 'concurrent/atomic/mutex_count_down_latch'
+require 'concurrent/atomic/java_count_down_latch'
+
+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