concurrent-ruby-edge 0.2.0.pre2 → 0.2.0.pre3

data/lib/concurrent/channel/buffer/buffered.rb

@@ -0,0 +1,127 @@
+require 'concurrent/channel/buffer/base'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      # A buffer with a fixed internal capacity. Items can be put onto the
+      # buffer without blocking until the internal capacity is reached. Once
+      # the buffer is at capacity, subsequent calls to {#put} will block until
+      # an item is removed from the buffer, creating spare capacity.
+      class Buffered < Base
+
+        # @!macro channel_buffer_initialize
+        #
+        # @param [Integer] size the maximum capacity of the buffer; must be
+        #   greater than zero.
+        # @raise [ArgumentError] when the size is zero (0) or less.
+        def initialize(size)
+          raise ArgumentError.new('size must be greater than 0') if size.to_i <= 0
+          super()
+          synchronize do
+            @size = size.to_i
+            @buffer = []
+          end
+        end
+
+        # @!macro channel_buffer_empty_question
+        def empty?
+          synchronize { ns_empty? }
+        end
+
+        # @!macro channel_buffer_full_question
+        #
+        # Will return `true` once the number of items in the buffer reaches
+        # the {#size} value specified during initialization.
+        def full?
+          synchronize { ns_full? }
+        end
+
+        # @!macro channel_buffer_put
+        #
+        # New items can be put onto the buffer until the number of items in
+        # the buffer reaches the {#size} value specified during
+        # initialization.
+        def put(item)
+          loop do
+            synchronize do
+              if ns_closed?
+                return false
+              elsif !ns_full?
+                ns_put_onto_buffer(item)
+                return true
+              end
+            end
+            Thread.pass
+          end
+        end
+
+        # @!macro channel_buffer_offer
+        #
+        # New items can be put onto the buffer until the number of items in
+        # the buffer reaches the {#size} value specified during
+        # initialization.
+        def offer(item)
+          synchronize do
+            if ns_closed? || ns_full?
+              return false
+            else
+              ns_put_onto_buffer(item)
+              return true
+            end
+          end
+        end
+
+        # @!macro channel_buffer_take
+        def take
+          item, _ = self.next
+          item
+        end
+
+        # @!macro channel_buffer_next
+        def next
+          loop do
+            synchronize do
+              if ns_closed? && ns_empty?
+                return NO_VALUE, false
+              elsif !ns_empty?
+                item = @buffer.shift
+                more = !ns_empty? || !ns_closed?
+                return item, more
+              end
+            end
+            Thread.pass
+          end
+        end
+
+        # @!macro channel_buffer_poll
+        def poll
+          synchronize do
+            if ns_empty?
+              NO_VALUE
+            else
+              @buffer.shift
+            end
+          end
+        end
+
+        private
+
+        # @!macro channel_buffer_empty_question
+        def ns_empty?
+          @buffer.length == 0
+        end
+
+        # @!macro channel_buffer_full_question
+        def ns_full?
+          @buffer.length == @size
+        end
+
+        # @!macro channel_buffer_put
+        def ns_put_onto_buffer(item)
+          @buffer.push(item)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/buffer/dropping.rb

@@ -0,0 +1,53 @@
+require 'concurrent/channel/buffer/base'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      # A non-blocking, buffered buffer of fixed maximum capacity. When the
+      # maximum capacity is reached subsequent {#put} and {#offer} operations
+      # will complete but the `put` item will be discarded; no transfer will
+      # occur.
+      class Dropping < Buffered
+
+        # @!method put(item)
+        #   @!macro channel_buffer_put
+        #
+        #   When the buffer is full, this method will return `true`
+        #   immediately but the item will be discarded. The item will *not*
+        #   be placed into the buffer (no transfer will occur).
+
+        # @!method offer(item)
+        #   @!macro channel_buffer_offer
+        #
+        #   When the buffer is full, this method will return `true`
+        #   immediately but the item will be discarded. The item will *not*
+        #   be placed into the buffer (no transfer will occur).
+
+        # @!method full?
+        #   @!macro channel_buffer_full_question
+        #
+        #   Always returns `false`.
+
+        # @!macro channel_buffer_blocking_question
+        #
+        # Always returns `false`.
+        def blocking?
+          false
+        end
+
+        private
+
+        # @!macro channel_buffer_full_question
+        def ns_full?
+          false
+        end
+
+        # @!macro channel_buffer_put
+        def ns_put_onto_buffer(item)
+          @buffer.push(item) unless @buffer.size == size
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/buffer/sliding.rb

@@ -0,0 +1,54 @@
+require 'concurrent/channel/buffer/base'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      # A non-blocking, buffered buffer of fixed maximum capacity. When the
+      # maximum capacity is reached subsequent {#put} and {#offer} operations
+      # will complete and the item will be `put`, but the oldest elements in
+      # the buffer will be discarded (not transferred).
+      class Sliding < Buffered
+
+        # @!method put(item)
+        #   @!macro channel_buffer_put
+        #
+        #   When the buffer is full, this method will return `true`
+        #   immediately and the item will be inserted, but the oldest
+        #   elements in the buffer will be discarded (not transferred).
+
+        # @!method offer(item)
+        #   @!macro channel_buffer_offer
+        #
+        #   When the buffer is full, this method will return `true`
+        #   immediately and the item will be inserted, but the oldest
+        #   elements in the buffer will be discarded (not transferred).
+
+        # @!method full?
+        #   @!macro channel_buffer_full_question
+        #
+        #   Always returns `false`.
+
+        # @!macro channel_buffer_blocking_question
+        #
+        # Always returns `false`.
+        def blocking?
+          false
+        end
+
+        private
+
+        # @!macro channel_buffer_full_question
+        def ns_full?
+          false
+        end
+
+        # @!macro channel_buffer_put
+        def ns_put_onto_buffer(item)
+          @buffer.shift if @buffer.size == size
+          @buffer.push(item)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/buffer/ticker.rb

@@ -0,0 +1,80 @@
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/channel/tick'
+require 'concurrent/channel/buffer/base'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      class Ticker < Base
+
+        def initialize(interval)
+          super()
+          synchronize do
+            @interval = interval.to_f
+            @next_tick = Concurrent.monotonic_time + interval
+          end
+        end
+
+        def size() 1; end
+
+        def empty?() false; end
+
+        def full?() true; end
+
+        def put(item)
+          false
+        end
+
+        def offer(item)
+          false
+        end
+
+        def take
+          loop do
+            result, _ = do_poll
+            if result.nil?
+              return NO_VALUE
+            elsif result != NO_VALUE
+              return result
+            end
+          end
+        end
+
+        def next
+          loop do
+            result, _ = do_poll
+            if result.nil?
+              return NO_VALUE, false
+            elsif result != NO_VALUE
+              return result, true
+            end
+          end
+        end
+
+        def poll
+          result, _ = do_poll
+          if result.nil? || result == NO_VALUE
+            NO_VALUE
+          else
+            result
+          end
+        end
+
+        private
+
+        def do_poll
+          if ns_closed?
+            return nil, false
+          elsif (now = Concurrent.monotonic_time) > @next_tick
+            tick = Concurrent::Channel::Tick.new(@next_tick)
+            @next_tick = now + @interval
+            return tick, true
+          else
+            return NO_VALUE, true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/buffer/timer.rb

@@ -0,0 +1,78 @@
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/channel/tick'
+require 'concurrent/channel/buffer/base'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      class Timer < Base
+
+        def initialize(delay)
+          super()
+          synchronize do
+            @tick = Concurrent.monotonic_time + delay.to_f
+            @closed = false
+            @empty = false
+          end
+        end
+
+        def size() 1; end
+
+        def empty?
+          synchronized { @empty }
+        end
+
+        def full?
+          !empty?
+        end
+
+        def put(item)
+          false
+        end
+
+        def offer(item)
+          false
+        end
+
+        def take
+          self.next.first
+        end
+
+        def next
+          loop do
+            status, tick = do_poll
+            if status == :tick
+              return tick, false
+              # AFAIK a Go timer will block forever if stopped
+              #elsif status == :closed
+              #return false, false
+            end
+            Thread.pass
+          end
+        end
+
+        def poll
+          status, tick = do_poll
+          status == :tick ? tick : NO_VALUE
+        end
+
+        private
+
+        def do_poll
+          synchronize do
+            return :closed, false if ns_closed?
+
+            if Concurrent.monotonic_time > @tick
+              # only one listener gets notified
+              @closed = @empty = true
+              return :tick, Concurrent::Channel::Tick.new(@tick)
+            else
+              return :wait, true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/buffer/unbuffered.rb

@@ -0,0 +1,151 @@
+require 'concurrent/channel/buffer/base'
+require 'concurrent/atomic/atomic_reference'
+
+module Concurrent
+  class Channel
+    module Buffer
+
+      # A blocking buffer with a size of zero. An item can only be put onto
+      # the buffer when a thread is waiting to take. Similarly, an item can
+      # only be put onto the buffer when a thread is waiting to put. When
+      # either {#put} or {#take} is called and there is no corresponding call
+      # in progress, the call will block indefinitely. Any other calls to the
+      # same method will queue behind the first call and block as well. As
+      # soon as a corresponding put/take call is made an exchange will occur
+      # and the first blocked call will return.
+      class Unbuffered < Base
+
+        # @!macro channel_buffer_initialize
+        def initialize
+          super
+          synchronize do
+            # one will always be empty
+            @putting = []
+            @taking = []
+            @closed = false
+          end
+        end
+
+        # @!macro channel_buffer_size_reader
+        # 
+        # Always returns zero (0).
+        def size() 0; end
+
+        # @!macro channel_buffer_empty_question
+        #
+        # Always returns `true`.
+        def empty?() true; end
+
+        # @!macro channel_buffer_full_question
+        #
+        # Always returns `false`.
+        def full?() false; end
+
+        # @!macro channel_buffer_put
+        #
+        # Items can only be put onto the buffer when one or more threads are
+        # waiting to {#take} items off the buffer. When there is a thread
+        # waiting to take an item this method will give its item and return
+        # immediately. When there are no threads waiting to take, this method
+        # will block. As soon as a thread calls `take` the exchange will
+        # occur and this method will return.
+        def put(item)
+          mine = synchronize do
+            return false if ns_closed?
+
+            ref = Concurrent::AtomicReference.new(item)
+            if @taking.empty?
+              @putting.push(ref)
+            else
+              taking = @taking.shift
+              taking.value = item
+              ref.value = nil
+            end
+            ref
+          end
+          loop do
+            return true if mine.value.nil?
+            Thread.pass
+          end
+        end
+
+        # @!macro channel_buffer_offer
+        #
+        # Items can only be put onto the buffer when one or more threads are
+        # waiting to {#take} items off the buffer. When there is a thread
+        # waiting to take an item this method will give its item and return
+        # `true` immediately. When there are no threads waiting to take or the
+        # buffer is closed, this method will return `false` immediately.
+        def offer(item)
+          synchronize do
+            return false if ns_closed? || @taking.empty?
+
+            taking = @taking.shift
+            taking.value = item
+            true
+          end
+        end
+
+        # @!macro channel_buffer_take
+        #
+        # Items can only be taken from the buffer when one or more threads are
+        # waiting to {#put} items onto the buffer. When there is a thread
+        # waiting to put an item this method will take that item and return it
+        # immediately. When there are no threads waiting to put, this method
+        # will block. As soon as a thread calls `pur` the exchange will occur
+        # and this method will return.
+        def take
+          mine = synchronize do
+            return NO_VALUE if ns_closed? && @putting.empty?
+
+            ref = Concurrent::AtomicReference.new(nil)
+            if @putting.empty?
+              @taking.push(ref)
+            else
+              putting = @putting.shift
+              ref.value = putting.value
+              putting.value = nil
+            end
+            ref
+          end
+          loop do
+            item = mine.value
+            return item if item
+            Thread.pass
+          end
+        end
+
+        # @!macro channel_buffer_poll
+        #
+        # Items can only be taken off the buffer when one or more threads are
+        # waiting to {#put} items onto the buffer. When there is a thread
+        # waiting to put an item this method will take the item and return
+        # it immediately. When there are no threads waiting to put or the
+        # buffer is closed, this method will return `NO_VALUE` immediately.
+        def poll
+          synchronize do
+            return NO_VALUE if @putting.empty?
+
+            putting = @putting.shift
+            value = putting.value
+            putting.value = nil
+            value
+          end
+        end
+
+        # @!macro channel_buffer_next
+        #
+        # Items can only be taken from the buffer when one or more threads are
+        # waiting to {#put} items onto the buffer. This method exhibits the
+        # same blocking behavior as {#take}.
+        #
+        # @see {#take}
+        def next
+          item = take
+          more = synchronize { !@putting.empty? }
+          return item, more
+        end
+      end
+    end
+  end
+end