class method

TSort.tsort_each

[T] (::TSort::_EachNode[T] each_node, ::TSort::_EachChild[T] each_child) { (T) -> void } -> void

[T] (::TSort::_EachNode[T] each_node, ::TSort::_EachChild[T] each_child) -> ::Enumerator[T, void]

[T] (^() { (T) -> void } -> void each_node, ^(T) { (T) -> void } -> void each_child) { (T) -> void } -> void

[T] (^() { (T) -> void } -> void each_node, ^(T) { (T) -> void } -> void each_child) -> ::Enumerator[T, void]

tsort_each(each_node, each_child) { |node| ... }

# File tmp/rubies/ruby-4.0.0/lib/tsort.rb, line 228
def self.tsort_each(each_node, each_child) # :yields: node
  return to_enum(__method__, each_node, each_child) unless block_given?

  each_strongly_connected_component(each_node, each_child) {|component|
    if component.size == 1
      yield component.first
    else
      raise Cyclic.new("topological sort failed: #{component.inspect}")
    end
  }
end

The iterator version of the TSort.tsort method.

The graph is represented by each_node and each_child. each_node should have call method which yields for each node in the graph. each_child should have call method which takes a node argument and yields for each child node.

Example

g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
each_node = lambda {|&b| g.each_key(&b) }
each_child = lambda {|n, &b| g[n].each(&b) }
TSort.tsort_each(each_node, each_child) {|n| p n }
#=> 4
#   2
#   3
#   1

See also #tsort_each .tsort #each_strongly_connected_component .strongly_connected_components also in 3.4 · 3.3 · 3.2 · 3.1 · 3.0

‹ prev.tsort next ›#each_strongly_connected_component