Class: Concurrent::Tuple — Concurrent

Class List Method List File List

# Class: Concurrent::Tuple

Inherits:
  Object
  - Object
  - Concurrent::Tuple
  show all
Includes:
  Enumerable
Defined in:
  lib/concurrent/tuple.rb

## Overview

A fixed size array with volatile (synchronized, thread safe) getters/setters. Mixes in Ruby's `Enumerable` module for enhanced search, sort, and traversal.

Examples:

    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 Also:

- Tuple entry at Wikipedia
- Erlang Tuple
- Enumerable

## Constant Summary

## Instance Attribute Summary (collapse)

- - (undocumented) size readonly

  The (fixed) size of the tuple.

## Instance Method Summary (collapse)

- - (Boolean) compare_and_set(i, old_value, new_value) (also: #cas)

  Set the value at the given index to the new value if and only if the current value matches the given old value.

- - (undocumented) each {|ref| ... }

  Calls the given block once for each element in self, passing that element as a parameter.

- - (Object) get(i) (also: #volatile_get)

  Get the value of the element at the given index.

- - (Tuple) initialize(size) constructor

  Create a new tuple of the given size.

- - (Object) set(i, value) (also: #volatile_set)

  Set the element at the given index to the given value.

## Constructor Details

### - (`Tuple`) initialize(size)

Create a new tuple of the given size.

Parameters:

- size (`Integer`) —

  the number of elements in the tuple

    33
    34
    35
    36
    37
    38
    39
    40
    41
    # File 'lib/concurrent/tuple.rb', line 33

    def initialize(size)
      @size = size
      @tuple = tuple = Tuple.new(size)
      i = 0
      while i < size
        tuple[i] = Concurrent::AtomicReference.new
        i += 1
      end
    end

## Instance Attribute Details

### - (`undocumented`) size (readonly)

The (fixed) size of the tuple.

    24
    25
    26
    # File 'lib/concurrent/tuple.rb', line 24

    def size
      @size
    end

## Instance Method Details

### - (`Boolean`) compare_and_set(i, old_value, new_value) Also known as: cas

Set the value at the given index to the new value if and only if the current value matches the given old value.

Parameters:

- i (`Integer`) —

  the index for the element to set

- old_value (`Object`) —

  the value to compare against the current value

- new_value (`Object`) —

  the value to set at the given index

Returns:

- (`Boolean`) —

  true if the value at the given element was set else false

    73
    74
    75
    76
    # File 'lib/concurrent/tuple.rb', line 73

    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

### - (`undocumented`) each {|ref| ... }

Calls the given block once for each element in self, passing that element as a parameter.

Yield Parameters:

- ref (`Object`) —

  the `Concurrent::AtomicReference` object at the current index

    82
    83
    84
    # File 'lib/concurrent/tuple.rb', line 82

    def each
      @tuple.each {|ref| yield ref.get}
    end

### - (`Object`) get(i) Also known as: volatile_get

Get the value of the element at the given index.

Parameters:

- i (`Integer`) —

  the index from which to retrieve the value

Returns:

- (`Object`) —

  the value at the given index or nil if the index is out of bounds

    47
    48
    49
    50
    # File 'lib/concurrent/tuple.rb', line 47

    def get(i)
      return nil if i >= @size || i < 0
      @tuple[i].get
    end

### - (`Object`) set(i, value) Also known as: volatile_set

Set the element at the given index to the given value

Parameters:

- i (`Integer`) —

  the index for the element to set

- value (`Object`) —

  the value to set at the given index

Returns:

- (`Object`) —

  the new value of the element at the given index or nil if the index is out of bounds

    59
    60
    61
    62
    # File 'lib/concurrent/tuple.rb', line 59

    def set(i, value)
      return nil if i >= @size || i < 0
      @tuple[i].set(value)
    end