Class: Roby::Queries::Index

Inherits:
Object show all
Defined in:
lib/roby/queries/index.rb

Overview

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

See Also:

Constant Summary collapse

STATE_PREDICATES = 
%I[
    pending? starting? running? finished? success? failed?
].freeze
PREDICATES = 
STATE_PREDICATES.dup.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Index

Returns a new instance of Index.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/roby/queries/index.rb', line 31

def initialize
    @by_model = Hash.new do |h, k|
        set = Set.new
        set.compare_by_identity
        h[k] = set
    end
    @by_predicate = {}
    @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 = {}
    @by_owner.compare_by_identity
    @mission_tasks = Set.new
    @permanent_tasks = Set.new
    @permanent_events = Set.new
end

Instance Attribute Details

#by_model ⇒ Object (readonly)

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



10
11
12
 
# File 'lib/roby/queries/index.rb', line 10

def by_model
  @by_model
end

#by_owner ⇒ Object (readonly)

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



16
17
18
 
# File 'lib/roby/queries/index.rb', line 16

def by_owner
  @by_owner
end

#by_predicate ⇒ Object (readonly)

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



14
15
16
 
# File 'lib/roby/queries/index.rb', line 14

def by_predicate
  @by_predicate
end

#mission_tasks ⇒ Object (readonly)

Set of mission tasks



20
21
22
 
# File 'lib/roby/queries/index.rb', line 20

def mission_tasks
  @mission_tasks
end

#permanent_events ⇒ Object (readonly)

Set of permanent events



24
25
26
 
# File 'lib/roby/queries/index.rb', line 24

def permanent_events
  @permanent_events
end

#permanent_tasks ⇒ Object (readonly)

Set of permanent tasks



22
23
24
 
# File 'lib/roby/queries/index.rb', line 22

def permanent_tasks
  @permanent_tasks
end

#self_owned ⇒ Object (readonly)

Tasks that are locally owned



18
19
20
 
# File 'lib/roby/queries/index.rb', line 18

def self_owned
  @self_owned
end

Instance Method Details

#add(task) ⇒ Object

Add a new task to this index



98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/roby/queries/index.rb', line 98

def add(task)
    task.model.ancestors.each do |klass|
        by_model[klass] << task
    end
    PREDICATES.each do |pred|
        by_predicate[pred] << task if task.send(pred)
    end
    self_owned << task if task.self_owned?
    task.owners.each do |owner|
        add_owner(task, owner)
    end
end

#add_owner(task, new_owner) ⇒ Object

Updates the index to reflect that new_owner now owns task



112
113
114
115
 
# File 'lib/roby/queries/index.rb', line 112

def add_owner(task, new_owner)
    self_owned << task if task.self_owned?
    (by_owner[new_owner] ||= Set.new) << task
end

#add_predicate(task, predicate) ⇒ Object 



142
143
144
 
# File 'lib/roby/queries/index.rb', line 142

def add_predicate(task, predicate)
    by_predicate[predicate] << task
end

#add_state(task, new_state) ⇒ Object 



134
135
136
 
# File 'lib/roby/queries/index.rb', line 134

def add_state(task, new_state)
    add_predicate(task, new_state)
end

#clear ⇒ Object 



87
88
89
90
91
92
93
94
95
 
# File 'lib/roby/queries/index.rb', line 87

def clear
    @by_model.clear
    @by_predicate.each_value(&:clear)
    @by_owner.clear
    @self_owned.clear
    @mission_tasks.clear
    @permanent_tasks.clear
    @permanent_events.clear
end

#initialize_copy(source) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/roby/queries/index.rb', line 66

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 = {}
    source.by_predicate.each do |state, set|
        by_predicate[state] = set.dup
    end

    @self_owned = source.self_owned.dup

    @by_owner = {}
    source.by_owner.each do |owner, set|
        by_owner[owner] = set.dup
    end
end

#merge(source) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/roby/queries/index.rb', line 53

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) ⇒ Object

Remove all references of task from the index.



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/roby/queries/index.rb', line 151

def remove(task)
    task.model.ancestors.each do |klass|
        set = by_model[klass]
        set.delete(task)
        by_model.delete(klass) if set.empty?
    end

    by_predicate.each do |state_set|
        state_set.last.delete(task)
    end

    self_owned.delete(task)
    task.owners.each do |owner|
        remove_owner(task, owner)
    end
end

#remove_owner(task, peer) ⇒ Object

Updates the index to reflect that peer no more owns task



118
119
120
121
122
123
124
 
# File 'lib/roby/queries/index.rb', line 118

def remove_owner(task, peer)
    if (set = by_owner[peer])
        set.delete(task)
        by_owner.delete(peer) if set.empty?
    end
    self_owned.delete(task) unless task.self_owned?
end

#remove_predicate(task, predicate) ⇒ Object 



146
147
148
 
# File 'lib/roby/queries/index.rb', line 146

def remove_predicate(task, predicate)
    by_predicate[predicate].delete(task)
end

#remove_state(task, state) ⇒ Object 



138
139
140
 
# File 'lib/roby/queries/index.rb', line 138

def remove_state(task, state)
    remove_predicate(task, state)
end

#set_state(task, new_state) ⇒ Object

Updates the index to reflect a change of state for task



127
128
129
130
131
132
 
# File 'lib/roby/queries/index.rb', line 127

def set_state(task, new_state)
    STATE_PREDICATES.each do |state|
        by_predicate[state].delete(task)
    end
    add_state(task, new_state)
end