concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/atomic/synchronization.rb

@@ -1,51 +0,0 @@
-module Concurrent
-
-  # Safe synchronization under JRuby, prevents reading uninitialized @mutex variable.
-  # @note synchronized needs to be called in #initialize for this module to work properly
-  # @example usage
-  #     class AClass
-  #       include Synchronized
-  #
-  #       def initialize
-  #         synchronize do
-  #           # body of the constructor ...
-  #         end
-  #       end
-  #
-  #       def a_method
-  #         synchronize do
-  #           # body of a_method ...
-  #         end
-  #       end
-  #     end
-  module Synchronization
-
-    engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-
-    case engine
-    when 'jruby'
-      require 'jruby'
-
-      def synchronize
-        JRuby.reference0(self).synchronized { yield }
-      end
-
-    when 'rbx'
-
-      def synchronize
-        Rubinius.lock(self)
-        yield
-      ensure
-        Rubinius.unlock(self)
-      end
-
-    else
-
-      def synchronize
-        @mutex ||= Mutex.new
-        @mutex.synchronize { yield }
-      end
-
-    end
-  end
-end

data/lib/concurrent/channel/buffered_channel.rb

@@ -1,85 +0,0 @@
-require 'concurrent/atomic/condition'
-
-require_relative 'waitable_list'
-
-module Concurrent
-  class BufferedChannel
-
-    def initialize(size)
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @buffer_condition = Condition.new
-
-      @probe_set = WaitableList.new
-      @buffer = RingBuffer.new(size)
-    end
-
-    def probe_set_size
-      @probe_set.size
-    end
-
-    def buffer_queue_size
-      @mutex.synchronize { @buffer.count }
-    end
-
-    def push(value)
-      until set_probe_or_push_into_buffer(value)
-      end
-    end
-
-    def pop
-      probe = Channel::Probe.new
-      select(probe)
-      probe.value
-    end
-
-    def select(probe)
-      @mutex.synchronize do
-
-        if @buffer.empty?
-          @probe_set.put(probe)
-          true
-        else
-          shift_buffer if probe.set_unless_assigned(peek_buffer, self)
-        end
-
-      end
-    end
-
-    def remove_probe(probe)
-      @probe_set.delete(probe)
-    end
-
-    private
-
-    def push_into_buffer(value)
-      @buffer_condition.wait(@mutex) while @buffer.full?
-      @buffer.offer value
-      @buffer_condition.broadcast
-    end
-
-    def peek_buffer
-      @buffer_condition.wait(@mutex) while @buffer.empty?
-      @buffer.peek
-    end
-
-    def shift_buffer
-      @buffer_condition.wait(@mutex) while @buffer.empty?
-      result = @buffer.poll
-      @buffer_condition.broadcast
-      result
-    end
-
-    def set_probe_or_push_into_buffer(value)
-      @mutex.synchronize do
-        if @probe_set.empty?
-          push_into_buffer(value)
-          true
-        else
-          @probe_set.take.set_unless_assigned(value, self)
-        end
-      end
-    end
-
-  end
-end

data/lib/concurrent/channel/channel.rb

@@ -1,41 +0,0 @@
-require 'concurrent/ivar'
-
-module Concurrent
-  module Channel
-
-    class Probe < Concurrent::IVar
-
-      def initialize(value = NO_VALUE, opts = {})
-        super(value, opts)
-      end
-
-      def set_unless_assigned(value, channel)
-        mutex.synchronize do
-          return false if [:fulfilled, :rejected].include? @state
-
-          set_state(true, [value, channel], nil)
-          event.set
-          true
-        end
-      end
-
-      alias_method :composite_value, :value
-
-      def value
-        composite_value.nil? ? nil : composite_value[0]
-      end
-
-      def channel
-        composite_value.nil? ? nil : composite_value[1]
-      end
-    end
-
-    def self.select(*channels)
-      probe = Probe.new
-      channels.each { |channel| channel.select(probe) }
-      result = probe.composite_value
-      channels.each { |channel| channel.remove_probe(probe) }
-      result
-    end
-  end
-end

data/lib/concurrent/channel/unbuffered_channel.rb

@@ -1,35 +0,0 @@
-require_relative 'waitable_list'
-
-module Concurrent
-  class UnbufferedChannel
-
-    def initialize
-      @probe_set = WaitableList.new
-    end
-
-    def probe_set_size
-      @probe_set.size
-    end
-
-    def push(value)
-      # TODO set_unless_assigned define on IVar as #set_state? or #try_set_state
-      until @probe_set.take.set_unless_assigned(value, self)
-      end
-    end
-
-    def pop
-      probe = Channel::Probe.new
-      select(probe)
-      probe.value
-    end
-
-    def select(probe)
-      @probe_set.put(probe)
-    end
-
-    def remove_probe(probe)
-      @probe_set.delete(probe)
-    end
-
-  end
-end

data/lib/concurrent/channel/waitable_list.rb

@@ -1,40 +0,0 @@
-require 'concurrent/atomic/condition'
-
-module Concurrent
-  class WaitableList
-
-    def initialize
-      @mutex = Mutex.new
-      @condition = Condition.new
-
-      @list = []
-    end
-
-    def size
-      @mutex.synchronize { @list.size }
-    end
-
-    def empty?
-      @mutex.synchronize { @list.empty? }
-    end
-
-    def put(value)
-      @mutex.synchronize do
-        @list << value
-        @condition.signal
-      end
-    end
-
-    def delete(value)
-      @mutex.synchronize { @list.delete(value) }
-    end
-
-    def take
-      @mutex.synchronize do
-        @condition.wait(@mutex) while @list.empty?
-        @list.shift
-      end
-    end
-
-  end
-end

data/lib/concurrent/channels.rb

@@ -1,5 +0,0 @@
-require 'concurrent/collections'
-
-require 'concurrent/channel/channel'
-require 'concurrent/channel/unbuffered_channel'
-require 'concurrent/channel/buffered_channel'

data/lib/concurrent/collection/blocking_ring_buffer.rb

@@ -1,71 +0,0 @@
-require 'concurrent/atomic/condition'
-
-module Concurrent
-  class BlockingRingBuffer
-
-    def initialize(capacity)
-      @buffer = RingBuffer.new(capacity)
-      @first = @last = 0
-      @count = 0
-      @mutex = Mutex.new
-      @condition = Condition.new
-    end
-
-    # @return [Integer] the capacity of the buffer
-    def capacity
-      @mutex.synchronize { @buffer.capacity }
-    end
-
-    # @return [Integer] the number of elements currently in the buffer
-    def count
-      @mutex.synchronize { @buffer.count }
-    end
-
-    # @return [Boolean] true if buffer is empty, false otherwise
-    def empty?
-      @mutex.synchronize { @buffer.empty? }
-    end
-
-    # @return [Boolean] true if buffer is full, false otherwise
-    def full?
-      @mutex.synchronize { @buffer.full? }
-    end
-
-    # @param [Object] value the value to be inserted
-    # @return [Boolean] true if value has been inserted, false otherwise
-    def put(value)
-      @mutex.synchronize do
-        wait_while_full
-        @buffer.offer(value)
-        @condition.signal
-        true
-      end
-    end
-
-    # @return [Object] the first available value and removes it from the buffer. If buffer is empty it blocks until an element is available
-    def take
-      @mutex.synchronize do
-        wait_while_empty
-        result = @buffer.poll
-        @condition.signal
-        result
-      end
-    end
-
-    # @return [Object] the first available value and without removing it from the buffer. If buffer is empty returns nil
-    def peek
-      @mutex.synchronize { @buffer.peek }
-    end
-
-    private
-
-    def wait_while_full
-      @condition.wait(@mutex) while @buffer.full?
-    end
-
-    def wait_while_empty
-      @condition.wait(@mutex) while @buffer.empty?
-    end
-
-  end
-end

data/lib/concurrent/collection/ring_buffer.rb

@@ -1,59 +0,0 @@
-module Concurrent
-
-  # non-thread safe buffer
-  class RingBuffer
-
-    def initialize(capacity)
-      @buffer = Array.new(capacity)
-      @first = @last = 0
-      @count = 0
-    end
-
-
-    # @return [Integer] the capacity of the buffer
-    def capacity
-      @buffer.size
-    end
-
-    # @return [Integer] the number of elements currently in the buffer
-    def count
-      @count
-    end
-
-    # @return [Boolean] true if buffer is empty, false otherwise
-    def empty?
-      @count == 0
-    end
-
-    # @return [Boolean] true if buffer is full, false otherwise
-    def full?
-      @count == capacity
-    end
-
-    # @param [Object] value
-    # @return [Boolean] true if value has been inserted, false otherwise
-    def offer(value)
-      return false if full?
-
-      @buffer[@last] = value
-      @last = (@last + 1) % @buffer.size
-      @count += 1
-      true
-    end
-
-    # @return [Object] the first available value and removes it from the buffer. If buffer is empty returns nil
-    def poll
-      result = @buffer[@first]
-      @buffer[@first] = nil
-      @first = (@first + 1) % @buffer.size
-      @count -= 1
-      result
-    end
-
-    # @return [Object] the first available value and without removing it from the buffer. If buffer is empty returns nil
-    def peek
-      @buffer[@first]
-    end
-
-  end
-end

data/lib/concurrent/collections.rb

@@ -1,3 +0,0 @@
-require 'concurrent/collection/priority_queue'
-require 'concurrent/collection/ring_buffer'
-require 'concurrent/collection/blocking_ring_buffer'

data/lib/concurrent/dereferenceable.rb

@@ -1,108 +0,0 @@
-module Concurrent
-
-  # Object references in Ruby are mutable. This can lead to serious problems when
-  # the `#value` of a concurrent object is a mutable reference. Which is always the
-  # case unless the value is a `Fixnum`, `Symbol`, or similar "primitive" data type.
-  # Most classes in this library that expose a `#value` getter method do so using the
-  # `Dereferenceable` mixin module. 
-  # 
-  # Objects with this mixin can be configured with a few options that can help protect
-  # the program from potentially dangerous operations.
-  # 
-  # * `:dup_on_deref` when true  will call the `#dup` method on the `value` object every time the `#value` method is called (default: false)
-  # * `:freeze_on_deref` when true  will call the `#freeze` method on the `value` object every time the `#value` method is called (default: false)
-  # * `:copy_on_deref` when given a `Proc` object the `Proc` will be run every time the `#value` method is called. The `Proc` will be given the current `value` as its only parameter and the result returned by the block will be the return value of the `#value` call. When `nil` this option will be ignored (default: nil)
-  module Dereferenceable
-
-    # Return the value this object represents after applying the options specified
-    # by the `#set_deref_options` method.
-    #
-    # When multiple deref options are set the order of operations is strictly defined.
-    # The order of deref operations is:
-    # * `:copy_on_deref`
-    # * `:dup_on_deref`
-    # * `:freeze_on_deref`
-    #
-    # Because of this ordering there is no need to `#freeze` an object created by a
-    # provided `:copy_on_deref` block. Simply set `:freeze_on_deref` to `true`.
-    # Setting both `:dup_on_deref` to `true` and `:freeze_on_deref` to `true` is
-    # as close to the behavior of a "pure" functional language (like Erlang, Clojure,
-    # or Haskell) as we are likely to get in Ruby.
-    # 
-    # This method is thread-safe and synchronized with the internal `#mutex`.
-    #
-    # @return [Object] the current value of the object
-    def value
-      mutex.lock
-      apply_deref_options(@value)
-    ensure
-      mutex.unlock
-    end
-
-    alias_method :deref, :value
-
-    protected
-
-    # Set the internal value of this object
-    #
-    # @param [Object] val the new value
-    def value=(val)
-      mutex.lock
-      @value = val
-    ensure
-      mutex.unlock
-    end
-
-    # A mutex lock used for synchronizing thread-safe operations. Methods defined
-    # by `Dereferenceable` are synchronized using the `Mutex` returned from this
-    # method. Operations performed by the including class that operate on the
-    # `@value` instance variable should be locked with this `Mutex`.
-    #
-    # @return [Mutex] the synchronization object
-    def mutex
-      @mutex
-    end
-
-    # Initializes the internal `Mutex`. 
-    #
-    # @note This method *must* be called from within the constructor of the including class.
-    #
-    # @see #mutex
-    def init_mutex
-      @mutex = Mutex.new
-    end
-
-    # Set the options which define the operations #value performs before
-    # returning data to the caller (dereferencing).
-    #
-    # @note Most classes that include this module will call `#set_deref_options`
-    # from within the constructor, thus allowing these options to be set at
-    # object creation.
-    #
-    # @param [Hash] opts the options defining dereference behavior.
-    # @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 set_deref_options(opts = {})
-      mutex.lock
-      @dup_on_deref = opts[:dup_on_deref] || opts[:dup]
-      @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
-      @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
-      @do_nothing_on_deref = !(@dup_on_deref || @freeze_on_deref || @copy_on_deref)
-      nil
-    ensure
-      mutex.unlock
-    end
-
-    # @!visibility private
-    def apply_deref_options(value) # :nodoc:
-      return nil if value.nil?
-      return value if @do_nothing_on_deref
-      value = @copy_on_deref.call(value) if @copy_on_deref
-      value = value.dup if @dup_on_deref
-      value = value.freeze if @freeze_on_deref
-      value
-    end
-  end
-end