concurrent-ruby 1.0.5 → 1.1.10

data/lib/concurrent/synchronization/mri_lockable_object.rb

@@ -1,71 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MriLockableObject < AbstractLockableObject
-      protected
-
-      def ns_signal
-        @__condition__.signal
-        self
-      end
-
-      def ns_broadcast
-        @__condition__.broadcast
-        self
-      end
-    end
-
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MriMutexLockableObject < MriLockableObject
-      safe_initialization!
-
-      def initialize(*defaults)
-        super(*defaults)
-        @__lock__      = ::Mutex.new
-        @__condition__ = ::ConditionVariable.new
-      end
-
-      protected
-
-      def synchronize
-        if @__lock__.owned?
-          yield
-        else
-          @__lock__.synchronize { yield }
-        end
-      end
-
-      def ns_wait(timeout = nil)
-        @__condition__.wait @__lock__, timeout
-        self
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MriMonitorLockableObject < MriLockableObject
-      safe_initialization!
-
-      def initialize(*defaults)
-        super(*defaults)
-        @__lock__      = ::Monitor.new
-        @__condition__ = @__lock__.new_cond
-      end
-
-      protected
-
-      def synchronize # TODO may be a problem with lock.synchronize { lock.wait }
-        @__lock__.synchronize { yield }
-      end
-
-      def ns_wait(timeout = nil)
-        @__condition__.wait timeout
-        self
-      end
-    end
-  end
-end

data/lib/concurrent/synchronization/truffle_lockable_object.rb

@@ -1,9 +0,0 @@
-module Concurrent
-  module Synchronization
-    class TruffleLockableObject < AbstractLockableObject
-      def new(*)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/concurrent/synchronization/truffle_object.rb

@@ -1,31 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    module TruffleAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          # TODO may not always be available
-          attr_atomic(*names)
-        end
-      end
-
-      def full_memory_barrier
-        Truffle::System.full_memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class TruffleObject < AbstractObject
-      include TruffleAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end

data/lib/concurrent/thread_safe/util/array_hash_rbx.rb

@@ -1,30 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-  module ThreadSafe
-    module Util
-      def self.make_synchronized_on_rbx(klass)
-        klass.class_eval do
-          private
-          def _mon_initialize
-            @_monitor = Monitor.new unless @_monitor # avoid double initialisation
-          end
-
-          def self.allocate
-            obj = super
-            obj.send(:_mon_initialize)
-            obj
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args)
-              @_monitor.synchronize { super }
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/utility/at_exit.rb

@@ -1,97 +0,0 @@
-require 'logger'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # Provides ability to add and remove handlers to be run at `Kernel#at_exit`, order is undefined.
-  # Each handler is executed at most once.
-  #
-  # @!visibility private
-  class AtExitImplementation < Synchronization::LockableObject
-    include Logger::Severity
-
-    def initialize(*args)
-      super()
-      synchronize { ns_initialize(*args) }
-    end
-
-    # Add a handler to be run at `Kernel#at_exit`
-    # @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
-    # @yield the handler
-    # @return id of the handler
-    def add(handler_id = nil, &handler)
-      id = handler_id || handler.object_id
-      synchronize { @handlers[id] = handler }
-      id
-    end
-
-    # Delete a handler by handler_id
-    # @return [true, false]
-    def delete(handler_id)
-      !!synchronize { @handlers.delete handler_id }
-    end
-
-    # Is handler with handler_id rpesent?
-    # @return [true, false]
-    def handler?(handler_id)
-      synchronize { @handlers.key? handler_id }
-    end
-
-    # @return copy of the handlers
-    def handlers
-      synchronize { @handlers }.clone
-    end
-
-    # install `Kernel#at_exit` callback to execute added handlers
-    def install
-      synchronize do
-        @installed ||= begin
-                         at_exit { runner }
-                         true
-                       end
-        self
-      end
-    end
-
-    # Will it run during `Kernel#at_exit`
-    def enabled?
-      synchronize { @enabled }
-    end
-
-    # Configure if it runs during `Kernel#at_exit`
-    def enabled=(value)
-      synchronize { @enabled = value }
-    end
-
-    # run the handlers manually
-    # @return ids of the handlers
-    def run
-      handlers, _ = synchronize { handlers, @handlers = @handlers, {} }
-      handlers.each do |_, handler|
-        begin
-          handler.call
-        rescue => error
-          Concurrent.global_logger.call(ERROR, error)
-        end
-      end
-      handlers.keys
-    end
-
-    private
-
-    def ns_initialize(enabled = true)
-      @handlers = {}
-      @enabled  = enabled
-    end
-
-    def runner
-      run if synchronize { @enabled }
-    end
-  end
-
-  private_constant :AtExitImplementation
-
-  # @see AtExitImplementation
-  # @!visibility private
-  AtExit = AtExitImplementation.new.install
-end

data/lib/concurrent/utility/monotonic_time.rb

@@ -1,58 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  class_definition = Class.new(Synchronization::LockableObject) do
-    def initialize
-      @last_time = Time.now.to_f
-      super()
-    end
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      # @!visibility private
-      def get_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    elsif Concurrent.on_jruby?
-      # @!visibility private
-      def get_time
-        java.lang.System.nanoTime() / 1_000_000_000.0
-      end
-    else
-
-      # @!visibility private
-      def get_time
-        synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-        end
-      end
-
-    end
-  end
-
-  # Clock that cannot be set and represents monotonic time since
-  # some unspecified starting point.
-  #
-  # @!visibility private
-  GLOBAL_MONOTONIC_CLOCK = class_definition.new
-  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
-  #     the elapsed monotonic time between `since` and the current time
-  #
-  #   @!macro monotonic_clock_warning
-  def monotonic_time
-    GLOBAL_MONOTONIC_CLOCK.get_time
-  end
-
-  module_function :monotonic_time
-end

data/lib/concurrent/utility/native_extension_loader.rb

@@ -1,73 +0,0 @@
-require 'concurrent/utility/engine'
-
-module Concurrent
-
-  module Utility
-
-    # @!visibility private
-    module NativeExtensionLoader
-
-      def allow_c_extensions?
-        Concurrent.on_cruby?
-      end
-
-      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
-
-        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
-  end
-
-  # @!visibility private
-  extend Utility::NativeExtensionLoader
-end
-

data/lib/concurrent/version.rb

@@ -1,4 +0,0 @@
-module Concurrent
-  VERSION      = '1.0.5'
-  EDGE_VERSION = '0.3.1'
-end