Moved VolatileTuple to top level and renamed Tuple.

Author: jdantonio

README.md

@@ -91,6 +91,7 @@ Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 * [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
 * [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
 * [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
+* [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
 
 #### Java-inspired ThreadPools and Other Executors
 

lib/concurrent.rb

@@ -26,6 +26,7 @@
 require 'concurrent/scheduled_task'
 require 'concurrent/settable_struct'
 require 'concurrent/timer_task'
+require 'concurrent/tuple'
 require 'concurrent/tvar'
 require 'concurrent/volatile'
 

lib/concurrent/thread_safe/util.rb

@@ -10,12 +10,12 @@ module Util
       MAX_INT         = (2 ** FIXNUM_BIT_SIZE) - 1
       CPU_COUNT       = 16 # is there a way to determine this?
 
+      autoload :Tuple,           'concurrent/tuple'
       autoload :Volatile,        'concurrent/volatile'
       autoload :Adder,           'concurrent/thread_safe/util/adder'
       autoload :CheapLockable,   'concurrent/thread_safe/util/cheap_lockable'
       autoload :PowerOfTwoTuple, 'concurrent/thread_safe/util/power_of_two_tuple'
       autoload :Striped64,       'concurrent/thread_safe/util/striped64'
-      autoload :VolatileTuple,   'concurrent/thread_safe/util/volatile_tuple'
       autoload :XorShiftRandom,  'concurrent/thread_safe/util/xor_shift_random'
     end
   end

lib/concurrent/thread_safe/util/power_of_two_tuple.rb

@@ -1,3 +1,5 @@
+require 'concurrent/tuple'
+
 module Concurrent
 
   # @!visibility private
@@ -7,7 +9,7 @@ module ThreadSafe
     module Util
 
       # @!visibility private
-      class PowerOfTwoTuple < VolatileTuple
+      class PowerOfTwoTuple < Concurrent::Tuple
 
         def initialize(size)
           raise ArgumentError, "size must be a power of 2 (#{size.inspect} provided)" unless size > 0 && size & (size - 1) == 0

lib/concurrent/tuple.rb

@@ -0,0 +1,86 @@
+require 'concurrent/atomic/atomic_reference'
+
+module Concurrent
+
+  # A fixed size array with volatile (synchronized, thread safe) getters/setters.
+  # Mixes in Ruby's `Enumerable` module for enhanced search, sort, and traversal.
+  #
+  # @example
+  #   tuple = Concurrent::Tuple.new(16)
+  #
+  #   tuple.set(0, :foo)                   #=> :foo  | volatile write
+  #   tuple.get(0)                         #=> :foo  | volatile read
+  #   tuple.compare_and_set(0, :foo, :bar) #=> true  | strong CAS
+  #   tuple.cas(0, :foo, :baz)             #=> false | strong CAS
+  #   tuple.get(0)                         #=> :bar  | volatile read
+  #
+  # @see https://en.wikipedia.org/wiki/Tuple Tuple entry at Wikipedia
+  # @see http://www.erlang.org/doc/reference_manual/data_types.html#id70396 Erlang Tuple
+  # @see http://ruby-doc.org/core-2.2.2/Enumerable.html Enumerable
+  class Tuple
+    include Enumerable
+
+    # The (fixed) size of the tuple.
+    attr_reader :size
+
+    # @!visibility private
+    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : Array
+    private_constant :Tuple
+
+    # Create a new tuple of the given size.
+    #
+    # @param [Integer] size the number of elements in the tuple
+    def initialize(size)
+      @size = size
+      @tuple = tuple = Tuple.new(size)
+      i = 0
+      while i < size
+        tuple[i] = Concurrent::AtomicReference.new
+        i += 1
+      end
+    end
+
+    # Get the value of the element at the given index.
+    #
+    # @param [Integer] i the index from which to retrieve the value
+    # @return [Object] the value at the given index or nil if the index is out of bounds
+    def get(i)
+      return nil if i >= @size || i < 0
+      @tuple[i].get
+    end
+    alias_method :volatile_get, :get
+
+    # Set the element at the given index to the given value
+    #
+    # @param [Integer] i the index for the element to set
+    # @param [Object] value the value to set at the given index
+    #
+    # @return [Object] the new value of the element at the given index or nil if the index is out of bounds
+    def set(i, value)
+      return nil if i >= @size || i < 0
+      @tuple[i].set(value)
+    end
+    alias_method :volatile_set, :set
+
+    # Set the value at the given index to the new value if and only if the current
+    # value matches the given old value.
+    #
+    # @param [Integer] i the index for the element to set
+    # @param [Object] old_value the value to compare against the current value
+    # @param [Object] new_value the value to set at the given index
+    #
+    # @return [Boolean] true if the value at the given element was set else false
+    def compare_and_set(i, old_value, new_value)
+      return false if i >= @size || i < 0
+      @tuple[i].compare_and_set(old_value, new_value)
+    end
+    alias_method :cas, :compare_and_set
+
+    # Calls the given block once for each element in self, passing that element as a parameter.
+    #
+    # @yieldparam [Object] ref the `Concurrent::AtomicReference` object at the current index
+    def each
+      @tuple.each {|ref| yield ref.get}
+    end
+  end
+end