class Roby::Queries::Index

Maintains a set of tasks as classified sets, speeding up query operations.

@see {Roby::Plan#task_index} {Roby::Queries::Query}

Constants

PREDICATES
STATE_PREDICATES

Attributes

by_model[R]

A model => Set map of the tasks for each model

by_owner[R]

A peer => Set map of tasks given their owner.

by_predicate[R]

A state => Set map of tasks given their state. The state is a symbol in [:pending, :starting, :running, :finishing, :finished]

self_owned[R]

Tasks that are locally owned

Public Class Methods

new() click to toggle source
# File lib/roby/queries/index.rb, line 21
def initialize
    @by_model = Hash.new do |h, k|
        set = Set.new
        set.compare_by_identity
        h[k] = set
    end
    @by_predicate = Hash.new
    @by_predicate.compare_by_identity
    STATE_PREDICATES.each do |state_name|
        set = Set.new
        set.compare_by_identity
        by_predicate[state_name] = set
    end
    @self_owned = Set.new
    @self_owned.compare_by_identity
    @by_owner = Hash.new
    @by_owner.compare_by_identity
end

Public Instance Methods

add(task) click to toggle source

Add a new task to this index

# File lib/roby/queries/index.rb, line 82
def add(task)
    for klass in task.model.ancestors
        by_model[klass] << task
    end
    for pred in PREDICATES
        if task.send(pred)
            by_predicate[pred] << task
        end
    end
    if task.self_owned?
        self_owned << task
    end
    for owner in task.owners
        add_owner(task, owner)
    end
end
add_owner(task, new_owner) click to toggle source

Updates the index to reflect that new_owner now owns task

# File lib/roby/queries/index.rb, line 100
def add_owner(task, new_owner)
    if task.self_owned?
        self_owned << task
    end
    (by_owner[new_owner] ||= Set.new) << task
end
add_predicate(task, predicate) click to toggle source
# File lib/roby/queries/index.rb, line 136
def add_predicate(task, predicate)
    by_predicate[predicate] << task
end
add_state(task, new_state) click to toggle source
# File lib/roby/queries/index.rb, line 128
def add_state(task, new_state)
    add_predicate(task, new_state)
end
clear() click to toggle source
# File lib/roby/queries/index.rb, line 74
def clear
    @by_model.clear
    @by_predicate.each_value(&:clear)
    @by_owner.clear
    @self_owned.clear
end
initialize_copy(source) click to toggle source
Calls superclass method
# File lib/roby/queries/index.rb, line 53
def initialize_copy(source)
    super

    @by_model = Hash.new { |h, k| h[k] = Set.new }
    source.by_model.each do |model, set|
        by_model[model] = set.dup
    end

    @by_predicate = Hash.new
    source.by_predicate.each do |state, set|
        by_predicate[state] = set.dup
    end

    @self_owned = source.self_owned.dup

    @by_owner = Hash.new
    source.by_owner.each do |owner, set|
        by_owner[owner] = set.dup
    end
end
merge(source) click to toggle source
# File lib/roby/queries/index.rb, line 40
def merge(source)
    source.by_model.each do |model, set|
        by_model[model].merge(set)
    end
    source.by_predicate.each do |state, set|
        by_predicate[state].merge(set)
    end
    self_owned.merge(source.self_owned)
    source.by_owner.each do |owner, set|
        (by_owner[owner] ||= Set.new).merge(set)
    end
end
remove(task) click to toggle source

Remove all references of task from the index.

# File lib/roby/queries/index.rb, line 146
def remove(task)
    for klass in task.model.ancestors
        set = by_model[klass]
        set.delete(task)
        if set.empty?
            by_model.delete(klass)
        end
    end
    for state_set in by_predicate
        state_set.last.delete(task)
    end
    self_owned.delete(task)
    for owner in task.owners
        remove_owner(task, owner)
    end
end
remove_owner(task, peer) click to toggle source

Updates the index to reflect that peer no more owns task

# File lib/roby/queries/index.rb, line 108
def remove_owner(task, peer)
    if set = by_owner[peer]
        set.delete(task)
        if set.empty?
            by_owner.delete(peer)
        end
    end
    if !task.self_owned?
        self_owned.delete(task)
    end
end
remove_predicate(task, predicate) click to toggle source
# File lib/roby/queries/index.rb, line 140
def remove_predicate(task, predicate)
    by_predicate[predicate].delete(task)
end
remove_state(task, state) click to toggle source
# File lib/roby/queries/index.rb, line 132
def remove_state(task, state)
    remove_predicate(task, state)
end
set_state(task, new_state) click to toggle source

Updates the index to reflect a change of state for task

# File lib/roby/queries/index.rb, line 121
def set_state(task, new_state)
    for state in STATE_PREDICATES
        by_predicate[state].delete(task)
    end
    add_state(task, new_state)
end