Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Static Private Attributes
xml.dom.minidom.Attr Class Reference
Inheritance diagram for xml.dom.minidom.Attr:
Inheritance graph
[legend]
Collaboration diagram for xml.dom.minidom.Attr:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def __setattr__
def unlink
def __bool__
def toxml
def toprettyxml
def hasChildNodes
def insertBefore
def appendChild
def replaceChild
def removeChild
def normalize
def cloneNode
def isSupported
def isSameNode
def getInterface
def getUserData
def setUserData
def __enter__
def __exit__

Public Attributes

 childNodes

Static Public Attributes

 nodeType = Node.ATTRIBUTE_NODE
 attributes = None
 ownerElement = None
 specified = False
 namespaceURI = None
 parentNode = None
 ownerDocument = None
 nextSibling = None
 previousSibling = None
 prefix = EMPTY_PREFIX
int ELEMENT_NODE = 1
int ATTRIBUTE_NODE = 2
int TEXT_NODE = 3
int CDATA_SECTION_NODE = 4
int ENTITY_REFERENCE_NODE = 5
int ENTITY_NODE = 6
int PROCESSING_INSTRUCTION_NODE = 7
int COMMENT_NODE = 8
int DOCUMENT_NODE = 9
int DOCUMENT_TYPE_NODE = 10
int DOCUMENT_FRAGMENT_NODE = 11
int NOTATION_NODE = 12

Private Member Functions

def _get_localName
def _get_name
def _get_specified
def _set_prefix
def _set_value
def _get_isId
def _get_schemaType

Static Private Attributes

 _is_id = False
tuple _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)

Detailed Description

Definition at line 344 of file minidom.py.


Constructor & Destructor Documentation

def xml.dom.minidom.Attr.__init__ (   self,
  qName,
  namespaceURI = EMPTY_NAMESPACE,
  localName = None,
  prefix = None 
)

Definition at line 354 of file minidom.py.

00354 
00355                  prefix=None):
00356         # skip setattr for performance
00357         d = self.__dict__
00358         d["nodeName"] = d["name"] = qName
00359         d["namespaceURI"] = namespaceURI
00360         d["prefix"] = prefix
00361         d['childNodes'] = NodeList()
00362 
00363         # Add the single child node that represents the value of the attr
00364         self.childNodes.append(Text())
00365 
00366         # nodeValue and value are set elsewhere

Here is the caller graph for this function:


Member Function Documentation

def xml.dom.minidom.Node.__bool__ (   self) [inherited]

Definition at line 43 of file minidom.py.

00043 
00044     def __bool__(self):
00045         return True

def xml.dom.minidom.Node.__enter__ (   self) [inherited]

Definition at line 273 of file minidom.py.

00273 
00274     def __enter__(self):
00275         return self

def xml.dom.minidom.Node.__exit__ (   self,
  et,
  ev,
  tb 
) [inherited]

Definition at line 276 of file minidom.py.

00276 
00277     def __exit__(self, et, ev, tb):
00278         self.unlink()
00279 
00280 defproperty(Node, "firstChild", doc="First child node, or None.")
00281 defproperty(Node, "lastChild",  doc="Last child node, or None.")
00282 defproperty(Node, "localName",  doc="Namespace-local name of this node.")
00283 

Here is the call graph for this function:

def xml.dom.minidom.Attr.__setattr__ (   self,
  name,
  value 
)

Definition at line 378 of file minidom.py.

00378 
00379     def __setattr__(self, name, value):
00380         d = self.__dict__
00381         if name in ("value", "nodeValue"):
00382             d["value"] = d["nodeValue"] = value
00383             d2 = self.childNodes[0].__dict__
00384             d2["data"] = d2["nodeValue"] = value
00385             if self.ownerElement is not None:
00386                 _clear_id_cache(self.ownerElement)
00387         elif name in ("name", "nodeName"):
00388             d["name"] = d["nodeName"] = value
00389             if self.ownerElement is not None:
00390                 _clear_id_cache(self.ownerElement)
00391         else:
00392             d[name] = value

Here is the call graph for this function:

def xml.dom.minidom.Attr._get_isId (   self) [private]

Definition at line 433 of file minidom.py.

00433 
00434     def _get_isId(self):
00435         if self._is_id:
00436             return True
00437         doc = self.ownerDocument
00438         elem = self.ownerElement
00439         if doc is None or elem is None:
00440             return False
00441 
00442         info = doc._get_elem_info(elem)
00443         if info is None:
00444             return False
00445         if self.namespaceURI:
00446             return info.isIdNS(self.namespaceURI, self.localName)
00447         else:
00448             return info.isId(self.nodeName)

def xml.dom.minidom.Attr._get_localName (   self) [private]

Reimplemented from xml.dom.minidom.Node.

Definition at line 367 of file minidom.py.

00367 
00368     def _get_localName(self):
00369         if 'localName' in self.__dict__:
00370             return self.__dict__['localName']
00371         return self.nodeName.split(":", 1)[-1]

def xml.dom.minidom.Attr._get_name (   self) [private]

Definition at line 372 of file minidom.py.

00372 
00373     def _get_name(self):
00374         return self.name

Here is the call graph for this function:

def xml.dom.minidom.Attr._get_schemaType (   self) [private]

Definition at line 449 of file minidom.py.

00449 
00450     def _get_schemaType(self):
00451         doc = self.ownerDocument
00452         elem = self.ownerElement
00453         if doc is None or elem is None:
00454             return _no_type
00455 
00456         info = doc._get_elem_info(elem)
00457         if info is None:
00458             return _no_type
00459         if self.namespaceURI:
00460             return info.getAttributeTypeNS(self.namespaceURI, self.localName)
00461         else:
00462             return info.getAttributeType(self.nodeName)
00463 
00464 defproperty(Attr, "isId",       doc="True if this attribute is an ID.")
00465 defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")
00466 defproperty(Attr, "schemaType", doc="Schema type for this attribute.")
00467 

Here is the call graph for this function:

def xml.dom.minidom.Attr._get_specified (   self) [private]

Definition at line 375 of file minidom.py.

00375 
00376     def _get_specified(self):
00377         return self.specified

def xml.dom.minidom.Attr._set_prefix (   self,
  prefix 
) [private]

Definition at line 393 of file minidom.py.

00393 
00394     def _set_prefix(self, prefix):
00395         nsuri = self.namespaceURI
00396         if prefix == "xmlns":
00397             if nsuri and nsuri != XMLNS_NAMESPACE:
00398                 raise xml.dom.NamespaceErr(
00399                     "illegal use of 'xmlns' prefix for the wrong namespace")
00400         d = self.__dict__
00401         d['prefix'] = prefix
00402         if prefix is None:
00403             newName = self.localName
00404         else:
00405             newName = "%s:%s" % (prefix, self.localName)
00406         if self.ownerElement:
00407             _clear_id_cache(self.ownerElement)
00408         d['nodeName'] = d['name'] = newName

Here is the call graph for this function:

def xml.dom.minidom.Attr._set_value (   self,
  value 
) [private]

Definition at line 409 of file minidom.py.

00409 
00410     def _set_value(self, value):
00411         d = self.__dict__
00412         d['value'] = d['nodeValue'] = value
00413         if self.ownerElement:
00414             _clear_id_cache(self.ownerElement)
00415         self.childNodes[0].data = value

Here is the call graph for this function:

def xml.dom.minidom.Node.appendChild (   self,
  node 
) [inherited]

Reimplemented in xml.dom.minidom.Document, and xml.dom.minidom.Entity.

Definition at line 113 of file minidom.py.

00113 
00114     def appendChild(self, node):
00115         if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
00116             for c in tuple(node.childNodes):
00117                 self.appendChild(c)
00118             ### The DOM does not clearly specify what to return in this case
00119             return node
00120         if node.nodeType not in self._child_node_types:
00121             raise xml.dom.HierarchyRequestErr(
00122                 "%s cannot be child of %s" % (repr(node), repr(self)))
00123         elif node.nodeType in _nodeTypes_with_children:
00124             _clear_id_cache(self)
00125         if node.parentNode is not None:
00126             node.parentNode.removeChild(node)
00127         _append_child(self, node)
00128         node.nextSibling = None
00129         return node

Here is the call graph for this function:

Here is the caller graph for this function:

def xml.dom.minidom.Node.cloneNode (   self,
  deep 
) [inherited]

Reimplemented in xml.dom.minidom.Document, and xml.dom.minidom.DocumentType.

Definition at line 205 of file minidom.py.

00205 
00206     def cloneNode(self, deep):
00207         return _clone_node(self, deep, self.ownerDocument or self)

Here is the call graph for this function:

def xml.dom.minidom.Node.getInterface (   self,
  feature 
) [inherited]

Definition at line 220 of file minidom.py.

00220 
00221     def getInterface(self, feature):
00222         if self.isSupported(feature, None):
00223             return self
00224         else:
00225             return None

Here is the call graph for this function:

def xml.dom.minidom.Node.getUserData (   self,
  key 
) [inherited]

Definition at line 230 of file minidom.py.

00230 
00231     def getUserData(self, key):
00232         try:
00233             return self._user_data[key][0]
00234         except (AttributeError, KeyError):
00235             return None

def xml.dom.minidom.Node.hasChildNodes (   self) [inherited]

Definition at line 64 of file minidom.py.

00064 
00065     def hasChildNodes(self):
00066         if self.childNodes:
00067             return True
00068         else:
00069             return False

def xml.dom.minidom.Node.insertBefore (   self,
  newChild,
  refChild 
) [inherited]

Reimplemented in xml.dom.minidom.Entity.

Definition at line 81 of file minidom.py.

00081 
00082     def insertBefore(self, newChild, refChild):
00083         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
00084             for c in tuple(newChild.childNodes):
00085                 self.insertBefore(c, refChild)
00086             ### The DOM does not clearly specify what to return in this case
00087             return newChild
00088         if newChild.nodeType not in self._child_node_types:
00089             raise xml.dom.HierarchyRequestErr(
00090                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
00091         if newChild.parentNode is not None:
00092             newChild.parentNode.removeChild(newChild)
00093         if refChild is None:
00094             self.appendChild(newChild)
00095         else:
00096             try:
00097                 index = self.childNodes.index(refChild)
00098             except ValueError:
00099                 raise xml.dom.NotFoundErr()
00100             if newChild.nodeType in _nodeTypes_with_children:
00101                 _clear_id_cache(self)
00102             self.childNodes.insert(index, newChild)
00103             newChild.nextSibling = refChild
00104             refChild.previousSibling = newChild
00105             if index:
00106                 node = self.childNodes[index-1]
00107                 node.nextSibling = newChild
00108                 newChild.previousSibling = node
00109             else:
00110                 newChild.previousSibling = None
00111             newChild.parentNode = self
00112         return newChild

Here is the call graph for this function:

Here is the caller graph for this function:

def xml.dom.minidom.Node.isSameNode (   self,
  other 
) [inherited]

Definition at line 217 of file minidom.py.

00217 
00218     def isSameNode(self, other):
00219         return self is other

Here is the caller graph for this function:

def xml.dom.minidom.Node.isSupported (   self,
  feature,
  version 
) [inherited]

Reimplemented in xml.dom.minidom.Document.

Definition at line 208 of file minidom.py.

00208 
00209     def isSupported(self, feature, version):
00210         return self.ownerDocument.implementation.hasFeature(feature, version)

Here is the caller graph for this function:

def xml.dom.minidom.Node.normalize (   self) [inherited]

Definition at line 178 of file minidom.py.

00178 
00179     def normalize(self):
00180         L = []
00181         for child in self.childNodes:
00182             if child.nodeType == Node.TEXT_NODE:
00183                 if not child.data:
00184                     # empty text node; discard
00185                     if L:
00186                         L[-1].nextSibling = child.nextSibling
00187                     if child.nextSibling:
00188                         child.nextSibling.previousSibling = child.previousSibling
00189                     child.unlink()
00190                 elif L and L[-1].nodeType == child.nodeType:
00191                     # collapse text node
00192                     node = L[-1]
00193                     node.data = node.data + child.data
00194                     node.nextSibling = child.nextSibling
00195                     if child.nextSibling:
00196                         child.nextSibling.previousSibling = node
00197                     child.unlink()
00198                 else:
00199                     L.append(child)
00200             else:
00201                 L.append(child)
00202                 if child.nodeType == Node.ELEMENT_NODE:
00203                     child.normalize()
00204         self.childNodes[:] = L

def xml.dom.minidom.Node.removeChild (   self,
  oldChild 
) [inherited]

Reimplemented in xml.dom.minidom.Document, and xml.dom.minidom.Entity.

Definition at line 162 of file minidom.py.

00162 
00163     def removeChild(self, oldChild):
00164         try:
00165             self.childNodes.remove(oldChild)
00166         except ValueError:
00167             raise xml.dom.NotFoundErr()
00168         if oldChild.nextSibling is not None:
00169             oldChild.nextSibling.previousSibling = oldChild.previousSibling
00170         if oldChild.previousSibling is not None:
00171             oldChild.previousSibling.nextSibling = oldChild.nextSibling
00172         oldChild.nextSibling = oldChild.previousSibling = None
00173         if oldChild.nodeType in _nodeTypes_with_children:
00174             _clear_id_cache(self)
00175 
00176         oldChild.parentNode = None
00177         return oldChild

Here is the call graph for this function:

Here is the caller graph for this function:

def xml.dom.minidom.Node.replaceChild (   self,
  newChild,
  oldChild 
) [inherited]

Reimplemented in xml.dom.minidom.Entity.

Definition at line 130 of file minidom.py.

00130 
00131     def replaceChild(self, newChild, oldChild):
00132         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
00133             refChild = oldChild.nextSibling
00134             self.removeChild(oldChild)
00135             return self.insertBefore(newChild, refChild)
00136         if newChild.nodeType not in self._child_node_types:
00137             raise xml.dom.HierarchyRequestErr(
00138                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
00139         if newChild is oldChild:
00140             return
00141         if newChild.parentNode is not None:
00142             newChild.parentNode.removeChild(newChild)
00143         try:
00144             index = self.childNodes.index(oldChild)
00145         except ValueError:
00146             raise xml.dom.NotFoundErr()
00147         self.childNodes[index] = newChild
00148         newChild.parentNode = self
00149         oldChild.parentNode = None
00150         if (newChild.nodeType in _nodeTypes_with_children
00151             or oldChild.nodeType in _nodeTypes_with_children):
00152             _clear_id_cache(self)
00153         newChild.nextSibling = oldChild.nextSibling
00154         newChild.previousSibling = oldChild.previousSibling
00155         oldChild.nextSibling = None
00156         oldChild.previousSibling = None
00157         if newChild.previousSibling:
00158             newChild.previousSibling.nextSibling = newChild
00159         if newChild.nextSibling:
00160             newChild.nextSibling.previousSibling = newChild
00161         return oldChild

Here is the call graph for this function:

def xml.dom.minidom.Node.setUserData (   self,
  key,
  data,
  handler 
) [inherited]

Definition at line 236 of file minidom.py.

00236 
00237     def setUserData(self, key, data, handler):
00238         old = None
00239         try:
00240             d = self._user_data
00241         except AttributeError:
00242             d = {}
00243             self._user_data = d
00244         if key in d:
00245             old = d[key][0]
00246         if data is None:
00247             # ignore handlers passed for None
00248             handler = None
00249             if old is not None:
00250                 del d[key]
00251         else:
00252             d[key] = (data, handler)
00253         return old

def xml.dom.minidom.Node.toprettyxml (   self,
  indent = "\t",
  newl = "\n",
  encoding = None 
) [inherited]

Definition at line 49 of file minidom.py.

00049 
00050     def toprettyxml(self, indent="\t", newl="\n", encoding=None):
00051         # indent = the indentation string to prepend, per level
00052         # newl = the newline string to append
00053         use_encoding = "utf-8" if encoding is None else encoding
00054         writer = codecs.getwriter(use_encoding)(io.BytesIO())
00055         if self.nodeType == Node.DOCUMENT_NODE:
00056             # Can pass encoding only to document, to put it into XML header
00057             self.writexml(writer, "", indent, newl, encoding)
00058         else:
00059             self.writexml(writer, "", indent, newl)
00060         if encoding is None:
00061             return writer.stream.getvalue().decode(use_encoding)
00062         else:
00063             return writer.stream.getvalue()

Here is the call graph for this function:

Here is the caller graph for this function:

def xml.dom.minidom.Node.toxml (   self,
  encoding = None 
) [inherited]

Definition at line 46 of file minidom.py.

00046 
00047     def toxml(self, encoding=None):
00048         return self.toprettyxml("", "", encoding)

Here is the call graph for this function:

Reimplemented from xml.dom.minidom.Node.

Definition at line 416 of file minidom.py.

00416 
00417     def unlink(self):
00418         # This implementation does not call the base implementation
00419         # since most of that is not needed, and the expense of the
00420         # method call is not warranted.  We duplicate the removal of
00421         # children, but that's all we needed from the base class.
00422         elem = self.ownerElement
00423         if elem is not None:
00424             del elem._attrs[self.nodeName]
00425             del elem._attrsNS[(self.namespaceURI, self.localName)]
00426             if self._is_id:
00427                 self._is_id = False
00428                 elem._magic_id_nodes -= 1
00429                 self.ownerDocument._magic_id_count -= 1
00430         for child in self.childNodes:
00431             child.unlink()
00432         del self.childNodes[:]


Member Data Documentation

Definition at line 351 of file minidom.py.

xml.dom.minidom.Attr._is_id = False [static, private]

Definition at line 349 of file minidom.py.

int xml.dom.Node.ATTRIBUTE_NODE = 2 [static, inherited]

Definition at line 29 of file __init__.py.

Definition at line 346 of file minidom.py.

int xml.dom.Node.CDATA_SECTION_NODE = 4 [static, inherited]

Definition at line 31 of file __init__.py.

int xml.dom.Node.COMMENT_NODE = 8 [static, inherited]

Definition at line 35 of file __init__.py.

int xml.dom.Node.DOCUMENT_FRAGMENT_NODE = 11 [static, inherited]

Definition at line 38 of file __init__.py.

int xml.dom.Node.DOCUMENT_NODE = 9 [static, inherited]

Definition at line 36 of file __init__.py.

int xml.dom.Node.DOCUMENT_TYPE_NODE = 10 [static, inherited]

Definition at line 37 of file __init__.py.

int xml.dom.Node.ELEMENT_NODE = 1 [static, inherited]

Definition at line 28 of file __init__.py.

int xml.dom.Node.ENTITY_NODE = 6 [static, inherited]

Definition at line 33 of file __init__.py.

int xml.dom.Node.ENTITY_REFERENCE_NODE = 5 [static, inherited]

Definition at line 32 of file __init__.py.

xml.dom.minidom.Node.namespaceURI = None [static, inherited]

Reimplemented in xml.dom.minidom.Element.

Definition at line 35 of file minidom.py.

xml.dom.minidom.Node.nextSibling = None [static, inherited]

Definition at line 38 of file minidom.py.

Reimplemented from xml.dom.minidom.Node.

Definition at line 345 of file minidom.py.

int xml.dom.Node.NOTATION_NODE = 12 [static, inherited]

Definition at line 39 of file __init__.py.

xml.dom.minidom.Node.ownerDocument = None [static, inherited]

Definition at line 37 of file minidom.py.

Definition at line 347 of file minidom.py.

xml.dom.minidom.Node.parentNode = None [static, inherited]

Reimplemented in xml.dom.minidom.Document, and xml.dom.minidom.DocumentFragment.

Definition at line 36 of file minidom.py.

Reimplemented in xml.dom.minidom.Element.

Definition at line 41 of file minidom.py.

xml.dom.minidom.Node.previousSibling = None [static, inherited]

Reimplemented in xml.dom.minidom.Document.

Definition at line 39 of file minidom.py.

Definition at line 34 of file __init__.py.

Definition at line 348 of file minidom.py.

int xml.dom.Node.TEXT_NODE = 3 [static, inherited]

Definition at line 30 of file __init__.py.


The documentation for this class was generated from the following file: