Class: Rinda::TupleSpace (Ruby 2.2.4)
Description: Class : Rinda::TupleSpace - Ruby 2.2.4

- Home
- Core 2.2.4
- Std-lib 2.2.4
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rinda/tuplespace.rb

### Parent

Object

### Methods

- ::new
- #move
- #notify
- #read
- #read_all
- #take
- #write

### Included Modules

- DRbUndumped
- MonitorMixin

### Class/Module Index

Quicksearch

- Rinda
- Rinda::DRbObjectTemplate
- Rinda::InvalidHashTupleKey
- Rinda::NotifyTemplateEntry
- Rinda::RequestCanceledError
- Rinda::RequestExpiredError
- Rinda::RindaError
- Rinda::RingFinger
- Rinda::RingProvider
- Rinda::RingServer
- Rinda::SimpleRenewer
- Rinda::Template
- Rinda::TemplateEntry
- Rinda::Tuple
- Rinda::TupleBag
- Rinda::TupleBag::TupleBin
- Rinda::TupleEntry
- Rinda::TupleSpace
- Rinda::TupleSpaceProxy
- Rinda::WaitTemplateEntry

No matching classes.

# Rinda::TupleSpace

The Tuplespace manages access to the tuples it contains, ensuring mutual exclusion requirements are met.

The `sec` option for the write, take, move, read and notify methods may either be a number of seconds or a Renewer object.

### Public Class Methods

new(period=60) click to toggle source

Creates a new TupleSpace. `period` is used to control how often to look for dead tuples after modifications to the TupleSpace.

If no dead tuples are found `period` seconds after the last modification, the TupleSpace will stop looking for dead tuples.

                   # File rinda/tuplespace.rb, line 438
    def initialize(period=60)
      super()
      @bag = TupleBag.new
      @read_waiter = TupleBag.new
      @take_waiter = TupleBag.new
      @notify_waiter = TupleBag.new
      @period = period
      @keeper = nil
    end

### Public Instance Methods

move(port, tuple, sec=nil) click to toggle source

Moves `tuple` to `port`.

                   # File rinda/tuplespace.rb, line 485
    def move(port, tuple, sec=nil)
      template = WaitTemplateEntry.new(self, tuple, sec)
      yield(template) if block_given?
      synchronize do
        entry = @bag.find(template)
        if entry
          port.push(entry.value) if port
          @bag.delete(entry)
          notify_event('take', entry.value)
          return port ? nil : entry.value
        end
        raise RequestExpiredError if template.expired?

        begin
          @take_waiter.push(template)
          start_keeper if template.expires
          while true
            raise RequestCanceledError if template.canceled?
            raise RequestExpiredError if template.expired?
            entry = @bag.find(template)
            if entry
              port.push(entry.value) if port
              @bag.delete(entry)
              notify_event('take', entry.value)
              return port ? nil : entry.value
            end
            template.wait
          end
        ensure
          @take_waiter.delete(template)
        end
      end
    end

notify(event, tuple, sec=nil) click to toggle source

Registers for notifications of `event`. Returns a NotifyTemplateEntry. See NotifyTemplateEntry for examples of how to listen for notifications.

`event` can be:

'write'

  A tuple was added

'take'

  A tuple was taken or moved

'delete'

  A tuple was lost after being overwritten or expiring

The TupleSpace will also notify you of the 'close' event when the NotifyTemplateEntry has expired.

                   # File rinda/tuplespace.rb, line 568
    def notify(event, tuple, sec=nil)
      template = NotifyTemplateEntry.new(self, event, tuple, sec)
      synchronize do
        @notify_waiter.push(template)
      end
      template
    end

read(tuple, sec=nil) click to toggle source

Reads `tuple`, but does not remove it.

                   # File rinda/tuplespace.rb, line 522
    def read(tuple, sec=nil)
      template = WaitTemplateEntry.new(self, tuple, sec)
      yield(template) if block_given?
      synchronize do
        entry = @bag.find(template)
        return entry.value if entry
        raise RequestExpiredError if template.expired?

        begin
          @read_waiter.push(template)
          start_keeper if template.expires
          template.wait
          raise RequestCanceledError if template.canceled?
          raise RequestExpiredError if template.expired?
          return template.found
        ensure
          @read_waiter.delete(template)
        end
      end
    end

read_all(tuple) click to toggle source

Returns all tuples matching `tuple`. Does not remove the found tuples.

                   # File rinda/tuplespace.rb, line 546
    def read_all(tuple)
      template = WaitTemplateEntry.new(self, tuple, nil)
      synchronize do
        entry = @bag.find_all(template)
        entry.collect do |e|
          e.value
        end
      end
    end

take(tuple, sec=nil, &block) click to toggle source

Removes `tuple`

                   # File rinda/tuplespace.rb, line 478
    def take(tuple, sec=nil, &block)
      move(nil, tuple, sec, &block)
    end

write(tuple, sec=nil) click to toggle source

Adds `tuple`

                   # File rinda/tuplespace.rb, line 451
    def write(tuple, sec=nil)
      entry = create_entry(tuple, sec)
      synchronize do
        if entry.expired?
          @read_waiter.find_all_template(entry).each do |template|
            template.read(tuple)
          end
          notify_event('write', entry.value)
          notify_event('delete', entry.value)
        else
          @bag.push(entry)
          start_keeper if entry.expires
          @read_waiter.find_all_template(entry).each do |template|
            template.read(tuple)
          end
          @take_waiter.find_all_template(entry).each do |template|
            template.signal
          end
          notify_event('write', entry.value)
        end
      end
      entry
    end