Class: Async::Node

Inherits:
Object
  • Object
show all
Defined in:
lib/async/node.rb

Overview

Represents a node in a tree, used for nested Task instances.

Direct Known Subclasses

Reactor, Task

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(parent = nil, annotation: nil, transient: false) ⇒ Node

Create a new node in the tree.

Parameters:

  • parent (Node, nil) (defaults to: nil) —

    This node will attach to the given parent.



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/async/node.rb', line 158

def initialize(parent = nil, annotation: nil, transient: false)
	@parent = nil
	@children = nil
	
	@annotation = annotation
	@object_name = nil
	
	@transient = transient
	
	@head = nil
	@tail = nil
	
	if parent
		parent.add_child(self)
	end
end

Instance Attribute Details

#annotation ⇒ Object (readonly)

A useful identifier for the current node.



187
188
189
 
# File 'lib/async/node.rb', line 187

def annotation
  @annotation
end

#children ⇒ Object (readonly) 



184
185
186
 
# File 'lib/async/node.rb', line 184

def children
  @children
end

#head ⇒ Object

You should not directly rely on these pointers but instead use ‘#children`. List pointers:



177
178
179
 
# File 'lib/async/node.rb', line 177

def head
  @head
end

#parent ⇒ Object 



181
182
183
 
# File 'lib/async/node.rb', line 181

def parent
  @parent
end

#tail ⇒ Object

Returns the value of attribute tail.



178
179
180
 
# File 'lib/async/node.rb', line 178

def tail
  @tail
end

Instance Method Details

#annotate(annotation) ⇒ Object 



199
200
201
202
203
204
205
206
207
208
 
# File 'lib/async/node.rb', line 199

def annotate(annotation)
	if block_given?
		previous_annotation = @annotation
		@annotation = annotation
		yield
		@annotation = previous_annotation
	else
		@annotation = annotation
	end
end

#backtrace(*arguments) ⇒ Object 



220
221
222
 
# File 'lib/async/node.rb', line 220

def backtrace(*arguments)
	nil
end

#children? ⇒ Boolean

Whether there are children?

Returns:

  • (Boolean) 


190
191
192
 
# File 'lib/async/node.rb', line 190

def children?
	@children != nil && !@children.empty?
end

#consume ⇒ Object

If the node has a parent, and is #finished?, then remove this node from the parent.



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
 
# File 'lib/async/node.rb', line 270

def consume
	if parent = @parent and finished?
		parent.delete_child(self)
		
		if @children
			@children.each do |child|
				if child.finished?
					delete_child(child)
				else
					parent.add_child(child)
				end
			end
			
			@children = nil
		end
		
		parent.consume
	end
end

#description ⇒ Object 



210
211
212
213
214
215
216
217
218
 
# File 'lib/async/node.rb', line 210

def description
	@object_name ||= "#{self.class}:0x#{object_id.to_s(16)}#{@transient ? ' transient' : nil}"
	
	if @annotation
		"#{@object_name} #{@annotation}"
	else
		@object_name
	end
end

#finished? ⇒ Boolean

Whether the node can be consumed safely. By default, checks if the children set is empty.

Returns:

  • (Boolean) 


264
265
266
 
# File 'lib/async/node.rb', line 264

def finished?
	@children.nil? || @children.finished?
end

#print_hierarchy(out = $stdout, backtrace: true) ⇒ Object 



304
305
306
307
308
309
310
311
312
 
# File 'lib/async/node.rb', line 304

def print_hierarchy(out = $stdout, backtrace: true)
	self.traverse do |node, level|
		indent = "\t" * level
		
		out.puts "#{indent}#{node}"
		
		print_backtrace(out, indent, node) if backtrace
	end
end

#stop ⇒ Object 



300
301
302
 
# File 'lib/async/node.rb', line 300

def stop
	@children&.each(&:stop)
end

#to_s ⇒ Object 



224
225
226
 
# File 'lib/async/node.rb', line 224

def to_s
	"\#<#{description}>"
end

#transient? ⇒ Boolean

Is this node transient?

Returns:

  • (Boolean) 


195
196
197
 
# File 'lib/async/node.rb', line 195

def transient?
	@transient
end

#traverse(level = 0) {|node, level| ... } ⇒ Object

Traverse the tree.

Yields:

  • (node, level) —

    The node and the level relative to the given root.



292
293
294
295
296
297
298
 
# File 'lib/async/node.rb', line 292

def traverse(level = 0, &block)
	yield self, level
	
	@children&.each do |child|
		child.traverse(level + 1, &block)
	end
end