6.3.2 Node Objects

class Node()

The Node class is the base class for all nodes in the plasT_eX DOM inluding elements, text, etc.

attributes

a dictionary containing the attributes, in the case of plasT_eX  the L^aT_eX macro arguments

childNodes

a list of the nodes that are contained by this one. In plasT_eX, this generally contains the contents of a L^aT_eX environment.

isElementContentWhitespace

boolean indicating whether or not the node only contains whitespace.

lastChild

the last node in the childNodes list. If there are no child nodes, the value is None.

nodeName

the name of the node. This is either the special node name as specified in the XML DOM (e.g. #document-fragment, #text, etc.), or, if the node corresponds to an element, it is the name of the element.

nodeType

integer indicating the type of the node. The node types are defined as:

• Node.ELEMENT_NODE

• Node.ATTRIBUTE_NODE

• Node.TEXT_NODE

• Node.CDATA_SECTION_NODE

• Node.ENTITY_REFERENCE_NODE

• Node.ENTITY_NODE

• Node.PROCESSING_INSTRUCTION_NODE

• Node.COMMENT_NODE

• Node.DOCUMENT_NODE

• Node.DOCUMENT_TYPE_NODE

• Node.DOCUMENT_FRAGMENT_NODE

• Node.NOTATION_NODE

Note: These are defined by the XML DOM, not all of them are used by plasT_eX.

parentNode

refers to the node that contains this node

previousSibling

the node in the document that is adjacent to and immediately before this node. If one does not exist, the value is None.

nextSibling

the node in the document that is adjacent to and immediately after this node. If one does not exist, the value is None.

ownerDocument

the node that owner of, and ultimate parent of, all nodes in the document

textContent

contains just the text content of this node

unicode

specifies a unicode string that could be used in place of the node. This unicode string will be converted into tokens in the plasT_eX  output stream.

userdata

dictionary used for holding user-defined data

__add__(other)

create a new node that is the sum of self and other. This allows you to use nodes in Python statements like: node + other.

append(newChild)

adds a new child to the end of the child nodes

appendChild(newChild)

same as append

cloneNode(deep=False)

create a clone of the current node. If deep is true, then the attributes and child nodes are cloned as well. Otherwise, all references to attributes and child nodes will be shared between the nodes.

__cmp__(other)

same as isEqualNode, but allows you to compare nodes using the Python statement: node == other.

extend(other)

appends other to list of children then returns self

__getitem__(i)

returns the child node at the index given by i. This allows you to use Python’s slicing syntax to retrieve child nodes: node[i].

getUserData(key)

retrieves the data in the userdata dictionary under the name key

hasAttributes()

returns a boolean indicating whether or not this node has attributes defined

hasChildNodes()

returns a boolean indicating whether or not the node has child nodes

__iadd__(other)

same as extend. This allows you to use nodes in Python statements like: node += other.

insert(i, newChild)

inserts node newChild into position i in the child nodes list

insertBefore(newChild, refChild)

inserts newChild before refChild in this node. If refChild is not found, a NotFoundErr exception is raised.

isEqualNode(other)

indicates whether the given node is equivalent to this one

isSameNode(other)

indicates whether the given node is the same node as this one

__iter__()

returns an iterator that iterates over the child nodes. This allows you to use Python’s iter() function on nodes.

__len__()

returns the number of child nodes. This allows you to use Python’s len() function on nodes.

normalize()

combine consecutive text nodes and remove comments in this node

pop(index=-1)

removes child node and the index given by index. If no index is specified, the last child is removed.

__radd__(other)

create a new node that is the sum of other and self. This allows you to use nodes in Python statements like: other + node.

replaceChild(newChild, oldChild)

replaces oldChild with newChild in this node. If oldChild is not found, a NotFoundErr exception is raised.

removeChild(oldChild)

removes oldChild from this node. If oldChild is not found, a NotFoundErr exception is raised.

__setitem__(i, node)

sets the item at index i to node. This allows you to use Python’s slicing syntax to insert child nodes; see the example below.

mynode[5] = othernode
mynode[6:10] = [node1, node2]

setUserData(key, data)

put data specified in data into the userdata dictionary under the name given by key

toXML()

return an XML representation of the node