Module: REXML::Node

Module | REXML::Node
In: | rexml/node.rb

Represents a node in the tree. Nodes are never encountered except as superclasses of other objects. Nodes have siblings.

### Methods

each_recursive find_first_recursive indent index_in_parent next_sibling_node parent? previous_sibling_node to_s

### Public Instance methods

each_recursive() {|node| ...}

Visit all subnodes of `self` recursively

[Source]

    # File rexml/node.rb, line 42
                    def each_recursive(&block) # :yields: node
                            self.elements.each {|node|
                                    block.call(node)
                                    node.each_recursive(&block)
                            }
                    end

find_first_recursive() {|node| ...}

Find (and return) first subnode (recursively) for which the block evaluates to true. Returns `nil` if none was found.

[Source]

    # File rexml/node.rb, line 51
                    def find_first_recursive(&block) # :yields: node
          each_recursive {|node|
            return node if block.call(node)
          }
          return nil
        end

indent(to, ind)

[Source]

    # File rexml/node.rb, line 27
                    def indent to, ind
                            if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
                                    indentstyle = @parent.context[:indentstyle]
                            else
                                    indentstyle = '  '
                            end
                            to << indentstyle*ind unless ind<1
                    end

index_in_parent()

Returns the index that `self` has in its parent’s elements array, so that the following equation holds true:

      node == node.parent.elements[node.index_in_parent]

[Source]

    # File rexml/node.rb, line 62
        def index_in_parent
          parent.index(self)+1
        end

next_sibling_node()

@return the next sibling (nil if unset)

[Source]

    # File rexml/node.rb, line 8
                    def next_sibling_node
                            return nil if @parent.nil?
                            @parent[ @parent.index(self) + 1 ]
                    end

parent?()

[Source]

    # File rexml/node.rb, line 36
                    def parent?
                            false;
                    end

previous_sibling_node()

@return the previous sibling (nil if unset)

[Source]

    # File rexml/node.rb, line 14
                    def previous_sibling_node
                            return nil if @parent.nil?
                            ind = @parent.index(self)
                            return nil if ind == 0
                            @parent[ ind - 1 ]
                    end

to_s(indent=-1)

[Source]

    # File rexml/node.rb, line 21
                    def to_s indent=-1
                            rv = ""
                            write rv,indent
                            rv
                    end

[Validate]