concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/tvar.rb

@@ -1,12 +1,16 @@
 require 'set'
+require 'concurrent/synchronization'
 
 module Concurrent
 
   # A `TVar` is a transactional variable - a single-element container that
   # is used as part of a transaction - see `Concurrent::atomically`.
   #
+  # @!macro thread_safe_variable_comparison
+  #
   # {include:file:doc/tvar.md}
-  class TVar
+  class TVar < Synchronization::Object
+    safe_initialization!
 
     # Create a new `TVar` with an initial value.
     def initialize(value)

data/lib/concurrent/utility/at_exit.rb

@@ -7,7 +7,7 @@ module Concurrent
   # Each handler is executed at most once.
   #
   # @!visibility private
-  class AtExitImplementation < Synchronization::Object
+  class AtExitImplementation < Synchronization::LockableObject
     include Logger::Severity
 
     def initialize(*args)

data/lib/concurrent/utility/engine.rb

@@ -19,6 +19,10 @@ module Concurrent
         ruby_engine == 'rbx'
       end
 
+      def on_truffle?
+        ruby_engine == 'jruby+truffle'
+      end
+
       def on_windows?
         !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
       end

data/lib/concurrent/utility/monotonic_time.rb

@@ -2,11 +2,10 @@ require 'concurrent/synchronization'
 
 module Concurrent
 
-  class_definition = Class.new(Synchronization::Object) do
+  class_definition = Class.new(Synchronization::LockableObject) do
     def initialize
-      super()
       @last_time = Time.now.to_f
-      ensure_ivar_visibility!
+      super()
     end
 
     if defined?(Process::CLOCK_MONOTONIC)
@@ -44,7 +43,7 @@ module Concurrent
   private_constant :GLOBAL_MONOTONIC_CLOCK
 
   # @!macro [attach] monotonic_get_time
-  # 
+  #
   #   Returns the current time a tracked by the application monotonic clock.
   #
   #   @return [Float] The current monotonic time when `since` not given else

data/lib/concurrent/utility/native_extension_loader.rb

@@ -1,48 +1,67 @@
-require 'concurrent/synchronization/abstract_object' # for JRuby
 require 'concurrent/utility/engine'
 
 module Concurrent
+
   module Utility
 
     # @!visibility private
     module NativeExtensionLoader
 
-      @c_ext_loaded    ||= false
-      @java_ext_loaded ||= false
-
-      # @!visibility private
       def allow_c_extensions?
         Concurrent.on_cruby?
       end
 
-      if Concurrent.on_cruby? && !@c_ext_loaded
-        tries = [
-          lambda do
-            require 'concurrent/extension'
-            @c_ext_loaded = true
-          end,
-          lambda do
-            # may be a Windows cross-compiled native gem
-            require "concurrent/#{RUBY_VERSION[0..2]}/extension"
-            @c_ext_loaded = true
-          end]
-
-        tries.each do |try|
-          begin
-            try.call
-            break
-          rescue LoadError
-            next
+      def c_extensions_loaded?
+        @c_extensions_loaded ||= false
+      end
+
+      def java_extensions_loaded?
+        @java_extensions_loaded ||= false
+      end
+
+      def set_c_extensions_loaded
+        @c_extensions_loaded = true
+      end
+
+      def set_java_extensions_loaded
+        @java_extensions_loaded = true
+      end
+
+      def load_native_extensions
+        unless defined? Synchronization::AbstractObject
+          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
+        end
+
+        if Concurrent.on_cruby? && !c_extensions_loaded?
+          tries = [
+            lambda do
+              require 'concurrent/extension'
+              set_c_extensions_loaded
+            end,
+            lambda do
+              # may be a Windows cross-compiled native gem
+              require "concurrent/#{RUBY_VERSION[0..2]}/extension"
+              set_c_extensions_loaded
+            end]
+
+          tries.each do |try|
+            begin
+              try.call
+              break
+            rescue LoadError
+              next
+            end
           end
         end
-      end
 
-      if Concurrent.on_jruby? && !@java_ext_loaded
-        begin
-          require 'concurrent_ruby_ext'
-          @java_ext_loaded = true
-        rescue LoadError
-          # move on with pure-Ruby implementations
+        if Concurrent.on_jruby? && !java_extensions_loaded?
+          begin
+            require 'concurrent_ruby_ext'
+            set_java_extensions_loaded
+          rescue LoadError
+            # move on with pure-Ruby implementations
+            raise 'On JRuby but Java extensions failed to load.'
+          end
         end
       end
     end
@@ -51,3 +70,4 @@ module Concurrent
   # @!visibility private
   extend Utility::NativeExtensionLoader
 end
+

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '0.9.2'
-  EDGE_VERSION = '0.1.2'
+  VERSION      = '1.0.0'
+  EDGE_VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0
 platform: java
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2015-11-13 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -28,21 +28,31 @@ files:
 - LICENSE.txt
 - README.md
 - lib/concurrent.rb
+- lib/concurrent/agent.rb
+- lib/concurrent/array.rb
 - lib/concurrent/async.rb
 - lib/concurrent/atom.rb
+- lib/concurrent/atomic/abstract_thread_local_var.rb
 - lib/concurrent/atomic/atomic_boolean.rb
 - lib/concurrent/atomic/atomic_fixnum.rb
 - lib/concurrent/atomic/atomic_reference.rb
-- lib/concurrent/atomic/condition.rb
 - lib/concurrent/atomic/count_down_latch.rb
 - lib/concurrent/atomic/cyclic_barrier.rb
 - lib/concurrent/atomic/event.rb
+- lib/concurrent/atomic/java_count_down_latch.rb
+- lib/concurrent/atomic/java_thread_local_var.rb
+- lib/concurrent/atomic/mutex_atomic_boolean.rb
+- lib/concurrent/atomic/mutex_atomic_fixnum.rb
+- lib/concurrent/atomic/mutex_count_down_latch.rb
+- lib/concurrent/atomic/mutex_semaphore.rb
 - lib/concurrent/atomic/read_write_lock.rb
 - lib/concurrent/atomic/reentrant_read_write_lock.rb
+- lib/concurrent/atomic/ruby_thread_local_var.rb
 - lib/concurrent/atomic/semaphore.rb
 - lib/concurrent/atomic/thread_local_var.rb
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
 - lib/concurrent/atomic_reference/direct_update.rb
+- lib/concurrent/atomic_reference/jruby+truffle.rb
 - lib/concurrent/atomic_reference/jruby.rb
 - lib/concurrent/atomic_reference/mutex_atomic.rb
 - lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
@@ -51,67 +61,92 @@ files:
 - lib/concurrent/atomics.rb
 - lib/concurrent/collection/copy_on_notify_observer_set.rb
 - lib/concurrent/collection/copy_on_write_observer_set.rb
-- lib/concurrent/collection/priority_queue.rb
+- lib/concurrent/collection/java_non_concurrent_priority_queue.rb
+- lib/concurrent/collection/map/atomic_reference_map_backend.rb
+- lib/concurrent/collection/map/mri_map_backend.rb
+- lib/concurrent/collection/map/non_concurrent_map_backend.rb
+- lib/concurrent/collection/map/synchronized_map_backend.rb
+- lib/concurrent/collection/non_concurrent_priority_queue.rb
+- lib/concurrent/collection/ruby_non_concurrent_priority_queue.rb
 - lib/concurrent/concern/deprecation.rb
 - lib/concurrent/concern/dereferenceable.rb
 - lib/concurrent/concern/logging.rb
 - lib/concurrent/concern/obligation.rb
 - lib/concurrent/concern/observable.rb
 - lib/concurrent/configuration.rb
+- lib/concurrent/constants.rb
 - lib/concurrent/dataflow.rb
 - lib/concurrent/delay.rb
 - lib/concurrent/edge.rb
 - lib/concurrent/errors.rb
 - lib/concurrent/exchanger.rb
+- lib/concurrent/executor/abstract_executor_service.rb
 - lib/concurrent/executor/cached_thread_pool.rb
-- lib/concurrent/executor/executor.rb
 - lib/concurrent/executor/executor_service.rb
 - lib/concurrent/executor/fixed_thread_pool.rb
 - lib/concurrent/executor/immediate_executor.rb
 - lib/concurrent/executor/indirect_immediate_executor.rb
+- lib/concurrent/executor/java_executor_service.rb
 - lib/concurrent/executor/java_single_thread_executor.rb
 - lib/concurrent/executor/java_thread_pool_executor.rb
+- lib/concurrent/executor/ruby_executor_service.rb
 - lib/concurrent/executor/ruby_single_thread_executor.rb
 - lib/concurrent/executor/ruby_thread_pool_executor.rb
 - lib/concurrent/executor/safe_task_executor.rb
+- lib/concurrent/executor/serial_executor_service.rb
 - lib/concurrent/executor/serialized_execution.rb
+- lib/concurrent/executor/serialized_execution_delegator.rb
 - lib/concurrent/executor/simple_executor_service.rb
 - lib/concurrent/executor/single_thread_executor.rb
 - lib/concurrent/executor/thread_pool_executor.rb
 - lib/concurrent/executor/timer_set.rb
 - lib/concurrent/executors.rb
 - lib/concurrent/future.rb
+- lib/concurrent/hash.rb
 - lib/concurrent/immutable_struct.rb
 - lib/concurrent/ivar.rb
 - lib/concurrent/lazy_register.rb
+- lib/concurrent/map.rb
 - lib/concurrent/maybe.rb
 - lib/concurrent/mutable_struct.rb
 - lib/concurrent/mvar.rb
+- lib/concurrent/options.rb
 - lib/concurrent/promise.rb
 - lib/concurrent/scheduled_task.rb
 - lib/concurrent/settable_struct.rb
 - lib/concurrent/synchronization.rb
+- lib/concurrent/synchronization/abstract_lockable_object.rb
 - lib/concurrent/synchronization/abstract_object.rb
 - lib/concurrent/synchronization/abstract_struct.rb
 - lib/concurrent/synchronization/condition.rb
-- lib/concurrent/synchronization/java_object.rb
+- lib/concurrent/synchronization/jruby_lockable_object.rb
+- lib/concurrent/synchronization/jruby_object.rb
 - lib/concurrent/synchronization/lock.rb
-- lib/concurrent/synchronization/monitor_object.rb
-- lib/concurrent/synchronization/mutex_object.rb
+- lib/concurrent/synchronization/lockable_object.rb
+- lib/concurrent/synchronization/mri_lockable_object.rb
+- lib/concurrent/synchronization/mri_object.rb
 - lib/concurrent/synchronization/object.rb
+- lib/concurrent/synchronization/rbx_lockable_object.rb
 - lib/concurrent/synchronization/rbx_object.rb
+- lib/concurrent/synchronization/volatile.rb
+- lib/concurrent/thread_safe/synchronized_delegator.rb
+- lib/concurrent/thread_safe/util.rb
+- lib/concurrent/thread_safe/util/adder.rb
+- lib/concurrent/thread_safe/util/array_hash_rbx.rb
+- lib/concurrent/thread_safe/util/cheap_lockable.rb
+- lib/concurrent/thread_safe/util/power_of_two_tuple.rb
+- lib/concurrent/thread_safe/util/striped64.rb
+- lib/concurrent/thread_safe/util/volatile.rb
+- lib/concurrent/thread_safe/util/xor_shift_random.rb
 - lib/concurrent/timer_task.rb
+- lib/concurrent/tuple.rb
 - lib/concurrent/tvar.rb
-- lib/concurrent/utilities.rb
 - lib/concurrent/utility/at_exit.rb
 - lib/concurrent/utility/engine.rb
 - lib/concurrent/utility/monotonic_time.rb
 - lib/concurrent/utility/native_extension_loader.rb
 - lib/concurrent/utility/processor_counter.rb
-- lib/concurrent/utility/timeout.rb
-- lib/concurrent/utility/timer.rb
 - lib/concurrent/version.rb
-- lib/concurrent_ruby.rb
 - lib/concurrent_ruby_ext.jar
 homepage: http://www.concurrent-ruby.com
 licenses:

data/lib/concurrent/atomic/condition.rb

@@ -1,78 +0,0 @@
-require 'concurrent/utility/monotonic_time'
-require 'concurrent/concern/deprecation'
-
-module Concurrent
-
-  # Condition is a better implementation of standard Ruby ConditionVariable. The
-  # biggest difference is the wait return value: Condition#wait returns
-  # Condition::Result which make possible to know if waiting thread has been
-  # woken up by an another thread (using #signal or #broadcast) or due to
-  # timeout.
-  #
-  # Every #wait must be guarded by a locked Mutex or a ThreadError will be
-  # risen. Although it's not mandatory, it's recommended to call also #signal
-  # and #broadcast within the same mutex
-  #
-  # @deprecated
-  class Condition
-    include Concern::Deprecation
-
-    class Result
-      def initialize(remaining_time)
-        @remaining_time = remaining_time
-      end
-
-      attr_reader :remaining_time
-
-      # @return [Boolean] true if current thread has been waken up by a #signal
-      #  or a #broadcast call , otherwise false
-      def woken_up?
-        @remaining_time.nil? || @remaining_time > 0
-      end
-
-      # @return [Boolean] true if current thread has been waken up due to a
-      #   timeout, otherwise false
-      def timed_out?
-        @remaining_time != nil && @remaining_time <= 0
-      end
-
-      alias_method :can_wait?, :woken_up?
-
-    end
-
-    def initialize
-      deprecated 'Will be replaced with Synchronization::Object in v1.0.'
-      @condition = ConditionVariable.new
-    end
-
-    # @param [Mutex] mutex the locked mutex guarding the wait
-    # @param [Object] timeout nil means no timeout
-    # @return [Result]
-    #
-    # @!macro monotonic_clock_warning
-    def wait(mutex, timeout = nil)
-      start_time = Concurrent.monotonic_time
-      @condition.wait(mutex, timeout)
-
-      if timeout.nil?
-        Result.new(nil)
-      else
-        Result.new(start_time + timeout - Concurrent.monotonic_time)
-      end
-    end
-
-    # Wakes up a waiting thread
-    # @return [true]
-    def signal
-      @condition.signal
-      true
-    end
-
-    # Wakes up all waiting threads
-    # @return [true]
-    def broadcast
-      @condition.broadcast
-      true
-    end
-  end
-end

data/lib/concurrent/collection/priority_queue.rb

@@ -1,360 +0,0 @@
-module Concurrent
-  module Collection
-
-    # @!macro [attach] 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, `MutexPriorityQueue` 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.PriorityQueue`.
-    #
-    #   When running under JRuby the class `PriorityQueue` extends `JavaPriorityQueue`.
-    #   When running under all other interpreters it extends `MutexPriorityQueue`.
-    #
-    #   @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
-    # @!macro internal_implementation_note
-    class MutexPriorityQueue
-
-      # @!macro [attach] 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`
-      def initialize(opts = {})
-        order = opts.fetch(:order, :max)
-        @comparator = [:min, :low].include?(order) ? -1 : 1
-        clear
-      end
-
-      # @!macro [attach] priority_queue_method_clear
-      #
-      #   Removes all of the elements from this priority queue.
-      def clear
-        @queue = [nil]
-        @length = 0
-        true
-      end
-
-      # @!macro [attach] 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
-      def delete(item)
-        original_length = @length
-        k = 1
-        while k <= @length
-          if @queue[k] == item
-            swap(k, @length)
-            @length -= 1
-            sink(k)
-            @queue.pop
-          else
-            k += 1
-          end
-        end
-        @length != original_length
-      end
-
-      # @!macro [attach] priority_queue_method_empty
-      #  
-      #   Returns `true` if `self` contains no elements.
-      #  
-      #   @return [Boolean] true if there are no items in the queue else false
-      def empty?
-        size == 0
-      end
-
-      # @!macro [attach] 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
-      def include?(item)
-        @queue.include?(item)
-      end
-      alias_method :has_priority?, :include?
-
-      # @!macro [attach] priority_queue_method_length
-      #  
-      #   The current length of the queue.
-      #  
-      #   @return [Fixnum] the number of items in the queue
-      def length
-        @length
-      end
-      alias_method :size, :length
-
-      # @!macro [attach] 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
-      def peek
-        @queue[1]
-      end
-
-      # @!macro [attach] 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
-      def pop
-        max = @queue[1]
-        swap(1, @length)
-        @length -= 1
-        sink(1)
-        @queue.pop
-        max
-      end
-      alias_method :deq, :pop
-      alias_method :shift, :pop
-
-      # @!macro [attach] priority_queue_method_push
-      #  
-      #   Inserts the specified element into this priority queue.
-      #  
-      #   @param [Object] item the item to insert onto the queue
-      def push(item)
-        @length += 1
-        @queue << item
-        swim(@length)
-        true
-      end
-      alias_method :<<, :push
-      alias_method :enq, :push
-
-      # @!macro [attach] 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 [PriorityQueue] the newly created and populated queue
-      def self.from_list(list, opts = {})
-        queue = new(opts)
-        list.each{|item| queue << item }
-        queue
-      end
-
-      protected
-
-      # Exchange the values at the given indexes within the internal array.
-      # 
-      # @param [Integer] x the first index to swap
-      # @param [Integer] y the second index to swap
-      # 
-      # @!visibility private
-      def swap(x, y)
-        temp = @queue[x]
-        @queue[x] = @queue[y]
-        @queue[y] = temp
-      end
-
-      # Are the items at the given indexes ordered based on the priority
-      # order specified at construction?
-      #
-      # @param [Integer] x the first index from which to retrieve a comparable value
-      # @param [Integer] y the second index from which to retrieve a comparable value
-      #
-      # @return [Boolean] true if the two elements are in the correct priority order
-      #   else false
-      # 
-      # @!visibility private
-      def ordered?(x, y)
-        (@queue[x] <=> @queue[y]) == @comparator
-      end
-
-      # Percolate down to maintain heap invariant.
-      # 
-      # @param [Integer] k the index at which to start the percolation
-      # 
-      # @!visibility private
-      def sink(k)
-        while (j = (2 * k)) <= @length do
-          j += 1 if j < @length && ! ordered?(j, j+1)
-          break if ordered?(k, j)
-          swap(k, j)
-          k = j
-        end
-      end
-
-      # Percolate up to maintain heap invariant.
-      # 
-      # @param [Integer] k the index at which to start the percolation
-      # 
-      # @!visibility private
-      def swim(k)
-        while k > 1 && ! ordered?(k/2, k) do
-          swap(k, k/2)
-          k = k/2
-        end
-      end
-    end
-
-    if Concurrent.on_jruby?
-
-      # @!macro priority_queue
-      # 
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class JavaPriorityQueue
-
-        # @!macro priority_queue_method_initialize
-        def initialize(opts = {})
-          order = opts.fetch(:order, :max)
-          if [:min, :low].include?(order)
-            @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
-          else
-            @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
-          end
-        end
-
-        # @!macro priority_queue_method_clear
-        def clear
-          @queue.clear
-          true
-        end
-
-        # @!macro priority_queue_method_delete
-        def delete(item)
-          found = false
-          while @queue.remove(item) do
-            found = true
-          end
-          found
-        end
-
-        # @!macro priority_queue_method_empty
-        def empty?
-          @queue.size == 0
-        end
-
-        # @!macro priority_queue_method_include
-        def include?(item)
-          @queue.contains(item)
-        end
-        alias_method :has_priority?, :include?
-
-        # @!macro priority_queue_method_length
-        def length
-          @queue.size
-        end
-        alias_method :size, :length
-
-        # @!macro priority_queue_method_peek
-        def peek
-          @queue.peek
-        end
-
-        # @!macro priority_queue_method_pop
-        def pop
-          @queue.poll
-        end
-        alias_method :deq, :pop
-        alias_method :shift, :pop
-
-        # @!macro priority_queue_method_push
-        def push(item)
-          @queue.add(item)
-        end
-        alias_method :<<, :push
-        alias_method :enq, :push
-
-        # @!macro priority_queue_method_from_list
-        def self.from_list(list, opts = {})
-          queue = new(opts)
-          list.each{|item| queue << item }
-          queue
-        end
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    PriorityQueueImplementation = case
-                                  when Concurrent.on_jruby?
-                                    JavaPriorityQueue
-                                  else
-                                    MutexPriorityQueue
-                                  end
-    private_constant :PriorityQueueImplementation
-
-    # @!macro priority_queue
-    # 
-    # @!visibility private
-    class PriorityQueue < PriorityQueueImplementation
-
-      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
-
-      # @!method clear
-      #   @!macro priority_queue_method_clear
-
-      # @!method delete(item)
-      #   @!macro priority_queue_method_delete
-
-      # @!method empty?
-      #   @!macro priority_queue_method_empty
-
-      # @!method include?(item)
-      #   @!macro priority_queue_method_include
-
-      # @!method length
-      #   @!macro priority_queue_method_length
-
-      # @!method peek
-      #   @!macro priority_queue_method_peek
-
-      # @!method pop
-      #   @!macro priority_queue_method_pop
-
-      # @!method push(item)
-      #   @!macro priority_queue_method_push
-
-      # @!method self.from_list(list, opts = {})
-      #   @!macro priority_queue_method_from_list
-    end
-  end
-end