You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by tn...@apache.org on 2002/05/21 21:28:30 UTC
cvs commit: xml-xerces/c/src/xercesc/parsers XercesDOMParser.cpp XercesDOMParser.hpp
tng 02/05/21 12:28:29
Modified: c/src/xercesc/parsers XercesDOMParser.cpp
XercesDOMParser.hpp
Log:
DOM Reorganization: modify to use the new DOM interface.
Revision Changes Path
1.2 +145 -145 xml-xerces/c/src/xercesc/parsers/XercesDOMParser.cpp
Index: XercesDOMParser.cpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/parsers/XercesDOMParser.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesDOMParser.cpp 21 May 2002 19:27:31 -0000 1.1
+++ XercesDOMParser.cpp 21 May 2002 19:28:29 -0000 1.2
@@ -56,10 +56,10 @@
/**
* This file contains code to build the DOM tree. It registers a document
-* handler with the scanner. In these handler methods, appropriate IDOM nodes
+* handler with the scanner. In these handler methods, appropriate DOM nodes
* are created and added to the DOM tree.
*
-* $Id: XercesDOMParser.cpp,v 1.1 2002/05/21 19:27:31 tng Exp $
+* $Id: XercesDOMParser.cpp,v 1.2 2002/05/21 19:28:29 tng Exp $
*
*/
@@ -76,32 +76,32 @@
#include <xercesc/util/IOException.hpp>
#include <xercesc/internal/XMLScanner.hpp>
#include <xercesc/validators/DTD/DTDValidator.hpp>
-#include <xercesc/parsers/IDOMParser.hpp>
-#include <xercesc/idom/IDOM_DOMImplementation.hpp>
-#include <xercesc/idom/IDOM_Element.hpp>
-#include <xercesc/idom/IDAttrImpl.hpp>
-#include <xercesc/idom/IDOM_CDATASection.hpp>
-#include <xercesc/idom/IDOM_Comment.hpp>
-#include <xercesc/idom/IDTextImpl.hpp>
-#include <xercesc/idom/IDDocumentImpl.hpp>
-#include <xercesc/idom/IDDocumentTypeImpl.hpp>
-#include <xercesc/idom/IDOM_DocumentType.hpp>
-#include <xercesc/idom/IDElementImpl.hpp>
-#include <xercesc/idom/IDEntityImpl.hpp>
-#include <xercesc/idom/IDEntityReferenceImpl.hpp>
-#include <xercesc/idom/IDNotationImpl.hpp>
-#include <xercesc/idom/IDOM_NamedNodeMap.hpp>
-#include <xercesc/idom/IDOM_ProcessingInstruction.hpp>
-#include <xercesc/idom/IDNodeIDMap.hpp>
+#include <xercesc/parsers/XercesDOMParser.hpp>
+#include <xercesc/dom/DOMImplementation.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+#include <xercesc/dom/impl/DOMAttrImpl.hpp>
+#include <xercesc/dom/DOMCDATASection.hpp>
+#include <xercesc/dom/DOMComment.hpp>
+#include <xercesc/dom/impl/DOMTextImpl.hpp>
+#include <xercesc/dom/impl/DOMDocumentImpl.hpp>
+#include <xercesc/dom/impl/DOMDocumentTypeImpl.hpp>
+#include <xercesc/dom/DOMDocumentType.hpp>
+#include <xercesc/dom/impl/DOMElementImpl.hpp>
+#include <xercesc/dom/impl/DOMEntityImpl.hpp>
+#include <xercesc/dom/impl/DOMEntityReferenceImpl.hpp>
+#include <xercesc/dom/impl/DOMNotationImpl.hpp>
+#include <xercesc/dom/DOMNamedNodeMap.hpp>
+#include <xercesc/dom/DOMProcessingInstruction.hpp>
+#include <xercesc/dom/impl/DOMNodeIDMap.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
#include <xercesc/validators/DTD/DTDAttDefList.hpp>
// ---------------------------------------------------------------------------
-// IDOMParser: Constructors and Destructor
+// XercesDOMParser: Constructors and Destructor
// ---------------------------------------------------------------------------
-IDOMParser::IDOMParser(XMLValidator* const valToAdopt) :
+XercesDOMParser::XercesDOMParser(XMLValidator* const valToAdopt) :
fErrorHandler(0)
, fEntityResolver(0)
@@ -114,20 +114,20 @@
{
//
// Create a scanner and tell it what validator to use. Then set us
- // as the document event handler so we can fill the IDOM document.
+ // as the document event handler so we can fill the DOM document.
//
fScanner = new XMLScanner(valToAdopt);
fScanner->setDocHandler(this);
fScanner->setDocTypeHandler(this);
- fNodeStack = new ValueStackOf<IDOM_Node*>(64);
+ fNodeStack = new ValueStackOf<DOMNode*>(64);
this->reset();
}
-IDOMParser::~IDOMParser()
+XercesDOMParser::~XercesDOMParser()
{
if (fDocumentVector)
delete fDocumentVector;
@@ -138,13 +138,13 @@
}
-void IDOMParser::reset()
+void XercesDOMParser::reset()
{
// if fDocument exists already, store the old pointer in the vector for deletion later
if (fDocument) {
if (!fDocumentVector) {
// allocate the vector if not exists yet
- fDocumentVector = new RefVectorOf<IDDocumentImpl>(10, true) ;
+ fDocumentVector = new RefVectorOf<DOMDocumentImpl>(10, true) ;
}
fDocumentVector->addElement(fDocument);
}
@@ -162,34 +162,34 @@
// ---------------------------------------------------------------------------
-// IDOMParser: Getter methods
+// XercesDOMParser: Getter methods
// ---------------------------------------------------------------------------
-IDOM_Document* IDOMParser::getDocument()
+DOMDocument* XercesDOMParser::getDocument()
{
return fDocument;
}
-const XMLValidator& IDOMParser::getValidator() const
+const XMLValidator& XercesDOMParser::getValidator() const
{
return *fScanner->getValidator();
}
-bool IDOMParser::getDoNamespaces() const
+bool XercesDOMParser::getDoNamespaces() const
{
return fScanner->getDoNamespaces();
}
-bool IDOMParser::getExitOnFirstFatalError() const
+bool XercesDOMParser::getExitOnFirstFatalError() const
{
return fScanner->getExitOnFirstFatal();
}
-bool IDOMParser::getValidationConstraintFatal() const
+bool XercesDOMParser::getValidationConstraintFatal() const
{
return fScanner->getValidationConstraintFatal();
}
-IDOMParser::ValSchemes IDOMParser::getValidationScheme() const
+XercesDOMParser::ValSchemes XercesDOMParser::getValidationScheme() const
{
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
@@ -201,40 +201,40 @@
return Val_Auto;
}
-bool IDOMParser::getDoSchema() const
+bool XercesDOMParser::getDoSchema() const
{
return fScanner->getDoSchema();
}
-bool IDOMParser::getValidationSchemaFullChecking() const
+bool XercesDOMParser::getValidationSchemaFullChecking() const
{
return fScanner->getValidationSchemaFullChecking();
}
-int IDOMParser::getErrorCount() const
+int XercesDOMParser::getErrorCount() const
{
return fScanner->getErrorCount();
}
-XMLCh* IDOMParser::getExternalSchemaLocation() const
+XMLCh* XercesDOMParser::getExternalSchemaLocation() const
{
return fScanner->getExternalSchemaLocation();
}
-XMLCh* IDOMParser::getExternalNoNamespaceSchemaLocation() const
+XMLCh* XercesDOMParser::getExternalNoNamespaceSchemaLocation() const
{
return fScanner->getExternalNoNamespaceSchemaLocation();
}
// ---------------------------------------------------------------------------
-// IDOMParser: Setter methods
+// XercesDOMParser: Setter methods
// ---------------------------------------------------------------------------
-void IDOMParser::setDoNamespaces(const bool newState)
+void XercesDOMParser::setDoNamespaces(const bool newState)
{
fScanner->setDoNamespaces(newState);
}
-void IDOMParser::setErrorHandler(ErrorHandler* const handler)
+void XercesDOMParser::setErrorHandler(ErrorHandler* const handler)
{
fErrorHandler = handler;
if (fErrorHandler) {
@@ -247,7 +247,7 @@
}
}
-void IDOMParser::setEntityResolver(EntityResolver* const handler)
+void XercesDOMParser::setEntityResolver(EntityResolver* const handler)
{
fEntityResolver = handler;
if (fEntityResolver) {
@@ -260,17 +260,17 @@
}
}
-void IDOMParser::setExitOnFirstFatalError(const bool newState)
+void XercesDOMParser::setExitOnFirstFatalError(const bool newState)
{
fScanner->setExitOnFirstFatal(newState);
}
-void IDOMParser::setValidationConstraintFatal(const bool newState)
+void XercesDOMParser::setValidationConstraintFatal(const bool newState)
{
fScanner->setValidationConstraintFatal(newState);
}
-void IDOMParser::setValidationScheme(const ValSchemes newScheme)
+void XercesDOMParser::setValidationScheme(const ValSchemes newScheme)
{
if (newScheme == Val_Never)
fScanner->setValidationScheme(XMLScanner::Val_Never);
@@ -280,39 +280,39 @@
fScanner->setValidationScheme(XMLScanner::Val_Auto);
}
-void IDOMParser::setDoSchema(const bool newState)
+void XercesDOMParser::setDoSchema(const bool newState)
{
fScanner->setDoSchema(newState);
}
-void IDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
+void XercesDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
{
fScanner->setValidationSchemaFullChecking(schemaFullChecking);
}
-void IDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
+void XercesDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
{
fScanner->setExternalSchemaLocation(schemaLocation);
}
-void IDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
+void XercesDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
{
fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
}
-void IDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
+void XercesDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
{
fScanner->setExternalSchemaLocation(schemaLocation);
}
-void IDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
+void XercesDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
{
fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
}
// ---------------------------------------------------------------------------
-// IDOMParser: Parsing methods
+// XercesDOMParser: Parsing methods
// ---------------------------------------------------------------------------
-void IDOMParser::parse(const InputSource& source, const bool reuseGrammar)
+void XercesDOMParser::parse(const InputSource& source, const bool reuseGrammar)
{
// Avoid multiple entrance
if (fParseInProgress)
@@ -332,7 +332,7 @@
}
}
-void IDOMParser::parse(const XMLCh* const systemId, const bool reuseGrammar)
+void XercesDOMParser::parse(const XMLCh* const systemId, const bool reuseGrammar)
{
// Avoid multiple entrance
if (fParseInProgress)
@@ -352,7 +352,7 @@
}
}
-void IDOMParser::parse(const char* const systemId, const bool reuseGrammar)
+void XercesDOMParser::parse(const char* const systemId, const bool reuseGrammar)
{
// Avoid multiple entrance
if (fParseInProgress)
@@ -375,9 +375,9 @@
// ---------------------------------------------------------------------------
-// IDOMParser: Progressive parse methods
+// XercesDOMParser: Progressive parse methods
// ---------------------------------------------------------------------------
-bool IDOMParser::parseFirst( const XMLCh* const systemId
+bool XercesDOMParser::parseFirst( const XMLCh* const systemId
, XMLPScanToken& toFill
, const bool reuseGrammar)
{
@@ -391,7 +391,7 @@
return fScanner->scanFirst(systemId, toFill, reuseGrammar);
}
-bool IDOMParser::parseFirst( const char* const systemId
+bool XercesDOMParser::parseFirst( const char* const systemId
, XMLPScanToken& toFill
, const bool reuseGrammar)
{
@@ -405,7 +405,7 @@
return fScanner->scanFirst(systemId, toFill, reuseGrammar);
}
-bool IDOMParser::parseFirst( const InputSource& source
+bool XercesDOMParser::parseFirst( const InputSource& source
, XMLPScanToken& toFill
, const bool reuseGrammar)
{
@@ -419,12 +419,12 @@
return fScanner->scanFirst(source, toFill, reuseGrammar);
}
-bool IDOMParser::parseNext(XMLPScanToken& token)
+bool XercesDOMParser::parseNext(XMLPScanToken& token)
{
return fScanner->scanNext(token);
}
-void IDOMParser::parseReset(XMLPScanToken& token)
+void XercesDOMParser::parseReset(XMLPScanToken& token)
{
// Reset the scanner, and then reset the parser
fScanner->scanReset(token);
@@ -432,9 +432,9 @@
}
// ---------------------------------------------------------------------------
-// IDOMParser: Utilities
+// XercesDOMParser: Utilities
// ---------------------------------------------------------------------------
-void IDOMParser::resetDocumentPool()
+void XercesDOMParser::resetDocumentPool()
{
// We cannot enter here while a regular parse is in progress.
if (fParseInProgress)
@@ -449,9 +449,9 @@
// ---------------------------------------------------------------------------
-// IDOMParser: Implementation of the XMLErrorReporter interface
+// XercesDOMParser: Implementation of the XMLErrorReporter interface
// ---------------------------------------------------------------------------
-void IDOMParser::error( const unsigned int code
+void XercesDOMParser::error( const unsigned int code
, const XMLCh* const msgDomain
, const XMLErrorReporter::ErrTypes errType
, const XMLCh* const errorText
@@ -488,16 +488,16 @@
fErrorHandler->error(toThrow);
}
-void IDOMParser::resetErrors()
+void XercesDOMParser::resetErrors()
{
}
// ---------------------------------------------------------------------------
-// IDOMParser: Implementation of XMLEntityHandler interface
+// XercesDOMParser: Implementation of XMLEntityHandler interface
// ---------------------------------------------------------------------------
InputSource*
-IDOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
+XercesDOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
{
//
// Just map it to the SAX entity resolver. If there is not one installed,
@@ -511,9 +511,9 @@
// ---------------------------------------------------------------------------
-// IDOMParser: Implementation of XMLDocumentHandler interface
+// XercesDOMParser: Implementation of XMLDocumentHandler interface
// ---------------------------------------------------------------------------
-void IDOMParser::docCharacters( const XMLCh* const chars
+void XercesDOMParser::docCharacters( const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
@@ -521,7 +521,7 @@
if (!fWithinElement)
return;
- // idom_revisit. Is it really safe to null-terminate here?
+ // revisit. Is it really safe to null-terminate here?
// Does the scanner do it already?
// If scanner goes up to the very end of an unterminated
// buffer, we may be stepping on something bad here.
@@ -531,20 +531,20 @@
ncChars[length] = 0;
if (cdataSection == true)
{
- IDOM_CDATASection *node = fDocument->createCDATASection(chars);
+ DOMCDATASection *node = fDocument->createCDATASection(chars);
fCurrentParent->appendChild(node);
fCurrentNode = node;
}
else
{
- if (fCurrentNode->getNodeType() == IDOM_Node::TEXT_NODE)
+ if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
{
- IDOM_Text *node = (IDOM_Text *)fCurrentNode;
+ DOMText *node = (DOMText *)fCurrentNode;
node->appendData(chars);
}
else
{
- IDOM_Text *node = fDocument->createTextNode(chars);
+ DOMText *node = fDocument->createTextNode(chars);
fCurrentParent->appendChild(node);
fCurrentNode = node;
}
@@ -554,18 +554,18 @@
}
-void IDOMParser::docComment(const XMLCh* const comment)
+void XercesDOMParser::docComment(const XMLCh* const comment)
{
- IDOM_Comment *dcom = fDocument->createComment(comment);
+ DOMComment *dcom = fDocument->createComment(comment);
fCurrentParent->appendChild(dcom);
fCurrentNode = dcom;
}
-void IDOMParser::docPI( const XMLCh* const target
+void XercesDOMParser::docPI( const XMLCh* const target
, const XMLCh* const data)
{
- IDOM_ProcessingInstruction *pi = fDocument->createProcessingInstruction
+ DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
(
target
, data
@@ -575,12 +575,12 @@
}
-void IDOMParser::endEntityReference(const XMLEntityDecl& entDecl)
+void XercesDOMParser::endEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
- if (fCurrentParent->getNodeType() == IDOM_Node::ENTITY_REFERENCE_NODE) {
- IDEntityReferenceImpl *erImpl = (IDEntityReferenceImpl *) fCurrentParent;
+ if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
+ DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
erImpl->setReadOnly(true, true);
}
fCurrentParent = fNodeStack->pop();
@@ -589,7 +589,7 @@
}
-void IDOMParser::endElement( const XMLElementDecl& elemDecl
+void XercesDOMParser::endElement( const XMLElementDecl& elemDecl
, const unsigned int urlId
, const bool isRoot)
{
@@ -602,7 +602,7 @@
}
-void IDOMParser::ignorableWhitespace(const XMLCh* const chars
+void XercesDOMParser::ignorableWhitespace(const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
@@ -610,19 +610,19 @@
if (!fWithinElement || !fIncludeIgnorableWhitespace)
return;
- // idom_revisit. Not safe to slam in a null like this.
+ // revisit. Not safe to slam in a null like this.
XMLCh savedChar = chars[length];
XMLCh *ncChars = (XMLCh *)chars; // cast off const
ncChars[length] = chNull;
- if (fCurrentNode->getNodeType() == IDOM_Node::TEXT_NODE)
+ if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
{
- IDOM_Text *node = (IDOM_Text *)fCurrentNode;
+ DOMText *node = (DOMText *)fCurrentNode;
node->appendData(chars);
}
else
{
- IDTextImpl *node = (IDTextImpl *)fDocument->createTextNode(chars);
+ DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
node->setIgnorableWhitespace(true);
fCurrentParent->appendChild(node);
@@ -632,36 +632,36 @@
}
-void IDOMParser::resetDocument()
+void XercesDOMParser::resetDocument()
{
//
// The reset methods are called before a new parse event occurs.
// Reset this parsers state to clear out anything that may be left
- // from a previous use, in particular the IDOM document itself.
+ // from a previous use, in particular the DOM document itself.
//
this->reset();
- fDocument = (IDDocumentImpl *)IDOM_DOMImplementation::getImplementation()->createDocument();
+ fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument();
}
-void IDOMParser::startDocument()
+void XercesDOMParser::startDocument()
{
// Just set the document as the current parent and current node
fCurrentParent = fDocument;
fCurrentNode = fDocument;
- // set IDOM error checking off
+ // set DOM error checking off
fDocument->setErrorChecking(false);
}
-void IDOMParser::endDocument()
+void XercesDOMParser::endDocument()
{
- // set IDOM error checking back on
+ // set DOM error checking back on
fDocument->setErrorChecking(true);
}
-void IDOMParser::startElement(const XMLElementDecl& elemDecl
+void XercesDOMParser::startElement(const XMLElementDecl& elemDecl
, const unsigned int urlId
, const XMLCh* const elemPrefix
, const RefVectorOf<XMLAttr>& attrList
@@ -669,9 +669,9 @@
, const bool isEmpty
, const bool isRoot)
{
- IDOM_Element *elem;
+ DOMElement *elem;
- if (fScanner -> getDoNamespaces()) { //IDOM Level 2, doNamespaces on
+ if (fScanner -> getDoNamespaces()) { //DOM Level 2, doNamespaces on
XMLBuffer buf;
XMLCh* namespaceURI = 0;
if (urlId != fScanner->getEmptyNamespaceId()) { //TagName has a prefix
@@ -679,7 +679,7 @@
namespaceURI = buf.getRawBuffer();
}
elem = createElementNSNode(namespaceURI, elemDecl.getFullName());
- IDElementImpl *elemImpl = (IDElementImpl *) elem;
+ DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
for (unsigned int index = 0; index < attrCount; ++index) {
static const XMLCh XMLNS[] = {
chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
@@ -693,14 +693,14 @@
fScanner->getURIText(attrURIId, buf); //get namespaceURI
namespaceURI = buf.getRawBuffer();
}
- // idom_revisit. Optimize to init the named node map to the
+ // revisit. Optimize to init the named node map to the
// right size up front.
- IDAttrImpl *attr = (IDAttrImpl *)
+ DOMAttrImpl *attr = (DOMAttrImpl *)
fDocument->createAttributeNS(namespaceURI, oneAttrib->getQName());
attr->setValue(oneAttrib -> getValue());
elemImpl->setAttributeNode(attr);
- //IDAttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
+ //DOMAttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
// oneAttrib -> getValue());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
@@ -709,7 +709,7 @@
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (fDocument->fNodeIDMap == 0)
- fDocument->fNodeIDMap = new (fDocument) IDNodeIDMap(500, fDocument);
+ fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
fDocument->fNodeIDMap->add(attr);
attr->fNode.isIdAttr(true);
}
@@ -719,11 +719,11 @@
}
else { //DOM Level 1
elem = fDocument->createElement(elemDecl.getFullName());
- IDElementImpl *elemImpl = (IDElementImpl *) elem;
+ DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
for (unsigned int index = 0; index < attrCount; ++index) {
const XMLAttr* oneAttrib = attrList.elementAt(index);
//AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
- IDAttrImpl *attr = (IDAttrImpl *)
+ DOMAttrImpl *attr = (DOMAttrImpl *)
fDocument->createAttribute(oneAttrib->getName());
attr->setValue(oneAttrib -> getValue());
elemImpl->setAttributeNode(attr);
@@ -735,7 +735,7 @@
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (fDocument->fNodeIDMap == 0)
- fDocument->fNodeIDMap = new (fDocument) IDNodeIDMap(500, fDocument);
+ fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
fDocument->fNodeIDMap->add(attr);
attr->fNode.isIdAttr(true);
}
@@ -755,15 +755,15 @@
}
-void IDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
+void XercesDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
const XMLCh * entName = entDecl.getName();
- IDOM_EntityReference *er = fDocument->createEntityReference(entName);
+ DOMEntityReference *er = fDocument->createEntityReference(entName);
//set the readOnly flag to false before appending node, will be reset in endEntityReference
- IDEntityReferenceImpl *erImpl = (IDEntityReferenceImpl *) er;
+ DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
erImpl->setReadOnly(false, true);
fCurrentParent->appendChild(er);
@@ -775,15 +775,15 @@
// We'd decide later whether the entity nodes should be created by a
// separated method in parser or not. For now just stick it in if
// the ref nodes are created
- IDOM_NamedNodeMap *entities = fDocumentType->getEntities();
- IDEntityImpl* entity = (IDEntityImpl*)entities->getNamedItem(entName);
+ DOMNamedNodeMap *entities = fDocumentType->getEntities();
+ DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
entity->setEntityRef(er);
}
}
-void IDOMParser::XMLDecl(const XMLCh* const version
+void XercesDOMParser::XMLDecl(const XMLCh* const version
, const XMLCh* const encoding
, const XMLCh* const standalone
, const XMLCh* const actualEncStr)
@@ -792,17 +792,17 @@
}
// ---------------------------------------------------------------------------
-// IDOMParser: Helper methods
+// XercesDOMParser: Helper methods
// ---------------------------------------------------------------------------
-IDOM_Element* IDOMParser::createElementNSNode(const XMLCh *namespaceURI,
+DOMElement* XercesDOMParser::createElementNSNode(const XMLCh *namespaceURI,
const XMLCh *qualifiedName)
{
return fDocument->createElementNS(namespaceURI, qualifiedName);
}
// ---------------------------------------------------------------------------
-// IDOMParser: Deprecated methods
+// XercesDOMParser: Deprecated methods
// ---------------------------------------------------------------------------
-bool IDOMParser::getDoValidation() const
+bool XercesDOMParser::getDoValidation() const
{
//
// We don't want to tie the public parser classes to the enum used
@@ -816,7 +816,7 @@
return false;
}
-void IDOMParser::setDoValidation(const bool newState)
+void XercesDOMParser::setDoValidation(const bool newState)
{
fScanner->setDoValidation
(
@@ -825,7 +825,7 @@
}
//doctypehandler interfaces
-void IDOMParser::attDef
+void XercesDOMParser::attDef
(
const DTDElementDecl& elemDecl
, const DTDAttDef& attDef
@@ -940,7 +940,7 @@
}
}
-void IDOMParser::doctypeComment
+void XercesDOMParser::doctypeComment
(
const XMLCh* const comment
)
@@ -962,7 +962,7 @@
}
}
-void IDOMParser::doctypeDecl
+void XercesDOMParser::doctypeDecl
(
const DTDElementDecl& elemDecl
, const XMLCh* const publicId
@@ -970,12 +970,12 @@
, const bool hasIntSubset
)
{
- fDocumentType = (IDDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
+ fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
fDocument->setDocumentType(fDocumentType);
}
-void IDOMParser::doctypePI
+void XercesDOMParser::doctypePI
(
const XMLCh* const target
, const XMLCh* const data
@@ -999,7 +999,7 @@
}
-void IDOMParser::doctypeWhitespace
+void XercesDOMParser::doctypeWhitespace
(
const XMLCh* const chars
, const unsigned int length
@@ -1009,7 +1009,7 @@
fDocumentType->setInternalSubset(chars);
}
-void IDOMParser::elementDecl
+void XercesDOMParser::elementDecl
(
const DTDElementDecl& decl
, const bool isIgnored
@@ -1037,7 +1037,7 @@
}
}
-void IDOMParser::endAttList
+void XercesDOMParser::endAttList
(
const DTDElementDecl& elemDecl
)
@@ -1045,16 +1045,16 @@
// this section sets up default attributes.
// default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
// default attribute data attached to the document is used to conform to the
- // IDOM spec regarding creating element nodes & removing attributes with default values
+ // DOM spec regarding creating element nodes & removing attributes with default values
// see DocumentTypeImpl
if (elemDecl.hasAttDefs())
{
XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
XMLAttDef* attr = 0;
- IDAttrImpl * insertAttr = 0;
- IDOM_Element *elem = fDocument->createElement(elemDecl.getFullName());
- IDElementImpl *elemImpl = (IDElementImpl *) elem;
+ DOMAttrImpl * insertAttr = 0;
+ DOMElement *elem = fDocument->createElement(elemDecl.getFullName());
+ DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
while (defAttrs->hasMoreElements())
{
@@ -1068,7 +1068,7 @@
// So as long as the XML parser doesn't do it, it needs to
// done here.
const XMLCh* qualifiedName = attr->getFullName();
- int index = IDDocumentImpl::indexofQualifiedName(qualifiedName);
+ int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
XMLBuffer buf;
static const XMLCh XMLNS[] = {
@@ -1101,7 +1101,7 @@
buf.append(XMLUni::fgXMLNSURIName);
}
- insertAttr = (IDAttrImpl *) fDocument->createAttributeNS(
+ insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
buf.getRawBuffer(), // NameSpaceURI
qualifiedName); // qualified name
@@ -1109,7 +1109,7 @@
else
{
// Namespaces is turned off...
- insertAttr = (IDAttrImpl *) fDocument->createAttribute(attr->getFullName());
+ insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
}
insertAttr->setValue(attr->getValue());
elemImpl->setAttributeNode(insertAttr);
@@ -1120,32 +1120,32 @@
}
}
-void IDOMParser::endIntSubset()
+void XercesDOMParser::endIntSubset()
{
fDocumentType->intSubsetReading = false;
}
-void IDOMParser::endExtSubset()
+void XercesDOMParser::endExtSubset()
{
}
-void IDOMParser::entityDecl
+void XercesDOMParser::entityDecl
(
const DTDEntityDecl& entityDecl
, const bool isPEDecl
, const bool isIgnored
)
{
- IDEntityImpl* entity = (IDEntityImpl *) fDocument->createEntity(entityDecl.getName());
+ DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
entity->setPublicId(entityDecl.getPublicId());
entity->setSystemId(entityDecl.getSystemId());
entity->setNotationName(entityDecl.getNotationName());
- IDEntityImpl *previousDef = (IDEntityImpl *)
+ DOMEntityImpl *previousDef = (DOMEntityImpl *)
fDocumentType->getEntities()->setNamedItem( entity );
- #ifdef idom_revisit
+ #ifdef _revisit
//
// If this new entity node is replacing an entity node that was already
// in the entities named node map (happens if documents redefine the
@@ -1209,18 +1209,18 @@
}
-void IDOMParser::resetDocType()
+void XercesDOMParser::resetDocType()
{
fDocumentType = 0;
}
-void IDOMParser::notationDecl
+void XercesDOMParser::notationDecl
(
const XMLNotationDecl& notDecl
, const bool isIgnored
)
{
- IDNotationImpl* notation = (IDNotationImpl *)fDocument->createNotation(notDecl.getName());
+ DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
notation->setPublicId(notDecl.getPublicId());
notation->setSystemId(notDecl.getSystemId());
@@ -1228,23 +1228,23 @@
}
-void IDOMParser::startAttList
+void XercesDOMParser::startAttList
(
const DTDElementDecl& elemDecl
)
{
}
-void IDOMParser::startIntSubset()
+void XercesDOMParser::startIntSubset()
{
fDocumentType->intSubsetReading = true;
}
-void IDOMParser::startExtSubset()
+void XercesDOMParser::startExtSubset()
{
}
-void IDOMParser::TextDecl
+void XercesDOMParser::TextDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
1.2 +78 -78 xml-xerces/c/src/xercesc/parsers/XercesDOMParser.hpp
Index: XercesDOMParser.hpp
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/parsers/XercesDOMParser.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesDOMParser.hpp 21 May 2002 19:27:31 -0000 1.1
+++ XercesDOMParser.hpp 21 May 2002 19:28:29 -0000 1.2
@@ -55,22 +55,22 @@
*/
/*
- * $Id: XercesDOMParser.hpp,v 1.1 2002/05/21 19:27:31 tng Exp $
+ * $Id: XercesDOMParser.hpp,v 1.2 2002/05/21 19:28:29 tng Exp $
*
*/
-#if !defined(IDOMPARSER_HPP)
-#define IDOMPARSER_HPP
+#if !defined(XercesDOMParser_HPP)
+#define XercesDOMParser_HPP
-#include <xercesc/idom/IDOM_Document.hpp>
+#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/framework/XMLDocumentHandler.hpp>
#include <xercesc/framework/XMLErrorReporter.hpp>
#include <xercesc/framework/XMLEntityHandler.hpp>
#include <xercesc/util/ValueStackOf.hpp>
#include <xercesc/validators/DTD/DocTypeHandler.hpp>
-#include <xercesc/idom/IDOM_DocumentType.hpp>
+#include <xercesc/dom/DOMDocumentType.hpp>
#include <xercesc/validators/DTD/DTDElementDecl.hpp>
class EntityResolver;
@@ -78,9 +78,9 @@
class XMLPScanToken;
class XMLScanner;
class XMLValidator;
-class IDDocumentImpl;
-class IDDocumentTypeImpl;
-class IDOM_Element;
+class DOMDocumentImpl;
+class DOMDocumentTypeImpl;
+class DOMElement;
/**
@@ -93,7 +93,7 @@
* <p>It can be used to instantiate a validating or non-validating
* parser, by setting a member flag.</p>
*/
-class PARSERS_EXPORT IDOMParser :
+class PARSERS_EXPORT XercesDOMParser :
public XMLDocumentHandler
, public XMLErrorReporter
@@ -118,7 +118,7 @@
/** @name Constructors and Destructor */
//@{
- /** Construct a IDOMParser, with an optional validator
+ /** Construct a XercesDOMParser, with an optional validator
*
* Constructor with an instance of validator class to use for
* validation. If you don't provide a validator, a default one will
@@ -127,18 +127,18 @@
* @param valToAdopt Pointer to the validator instance to use. The
* parser is responsible for freeing the memory.
*/
- IDOMParser(XMLValidator* const valToAdopt = 0);
+ XercesDOMParser(XMLValidator* const valToAdopt = 0);
/**
* Destructor
*/
- virtual ~IDOMParser();
+ virtual ~XercesDOMParser();
//@}
/** Reset the parser
*
- * This method resets the state of the IDOM driver and makes
+ * This method resets the state of the DOM driver and makes
* it ready for a fresh parse run.
*/
void reset();
@@ -146,16 +146,16 @@
/** Reset the documents vector pool and release all the associated memory
* back to the system.
*
- * When parsing a document using an IDOMParser, all memory allocated
+ * When parsing a document using an XercesDOMParser, all memory allocated
* for a DOM tree is associated to the DOM document.
*
- * If you do multiple parse using the same IDOMParser instance, then
+ * If you do multiple parse using the same XercesDOMParser instance, then
* multiple DOM documents will be generated and saved in a vector pool.
* All these documents (and thus all the allocated memory)
* won't be deleted until the parser instance is destroyed.
*
* If you don't need these DOM documents anymore and don't want to
- * destroy the IDOMParser instance at this moment, then you can call this method
+ * destroy the XercesDOMParser instance at this moment, then you can call this method
* to reset the document vector pool and release all the allocated memory
* back to the system.
*
@@ -176,16 +176,16 @@
/** @name Getter methods */
//@{
- /** Get the IDOM document
+ /** Get the DOM document
*
- * This method returns the IDOM_Document object representing the
+ * This method returns the DOMDocument object representing the
* root of the document tree. This object provides the primary
* access to the document's data.
*
- * @return The IDOM_Document object which represents the entire
+ * @return The DOMDocument object which represents the entire
* XML document.
*/
- IDOM_Document* getDocument();
+ DOMDocument* getDocument();
/** Get a pointer to the error handler
*
@@ -538,7 +538,7 @@
* on non-validating parsers which always include non-markup text.
* <p>When set to true (also the default), ignorable whitespaces will be
* added to the DOM tree as text nodes. The method
- * IDOM_Text::isIgnorableWhitespace() will return true for those text
+ * DOMText::isIgnorableWhitespace() will return true for those text
* nodes only.
* <p>When set to false, all ignorable whitespace will be discarded and
* no text node is added to the DOM tree. Note: applications intended
@@ -688,7 +688,7 @@
* wrapping another exception.
* @exception XMLException An exception from the parser or client
* handler code.
- * @exception IDOM_DOMException A DOM exception as per DOM spec.
+ * @exception DOMException A DOM exception as per DOM spec.
* @see InputSource#InputSource
* @see #setEntityResolver
* @see #setErrorHandler
@@ -711,7 +711,7 @@
* wrapping another exception.
* @exception XMLException An exception from the parser or client
* handler code.
- * @exception DOM_DOMException A DOM exception as per DOM spec.
+ * @exception DOMException A DOM exception as per DOM spec.
* @see #parse(InputSource,...)
*/
void parse(const XMLCh* const systemId, const bool reuseGrammar = false);
@@ -731,7 +731,7 @@
* wrapping another exception.
* @exception XMLException An exception from the parser or client
* handler code.
- * @exception DOM_DOMException A DOM exception as per DOM spec.
+ * @exception DOMException A DOM exception as per DOM spec.
* @see #parse(InputSource,...)
*/
void parse(const char* const systemId, const bool reuseGrammar = false);
@@ -949,7 +949,7 @@
* This method allows the user installed Error Handler callback to
* 'reset' itself.
*
- * <b><font color="#FF0000">This method is a no-op for this IDOM
+ * <b><font color="#FF0000">This method is a no-op for this DOM
* implementation.</font></b>
*/
virtual void resetErrors();
@@ -968,7 +968,7 @@
* This method is used to indicate the end of parsing of an external
* entity file.
*
- * <b><font color="#FF0000">This method is a no-op for this IDOM
+ * <b><font color="#FF0000">This method is a no-op for this DOM
* implementation.</font></b>
*
* @param inputSource A const reference to the InputSource object
@@ -984,7 +984,7 @@
* the XML file being parsed, such as redirection etc.
*
* <b><font color="#FF0000">This method always returns 'false'
- * for this IDOM implementation.</font></b>
+ * for this DOM implementation.</font></b>
*
* @param systemId A const pointer to an Unicode string representing
* the system id scanned by the parser.
@@ -1003,7 +1003,7 @@
* This method allows the installed XMLEntityHandler to reset
* itself.
*
- * <b><font color="#FF0000">This method is a no-op for this IDOM
+ * <b><font color="#FF0000">This method is a no-op for this DOM
* implementation.</font></b>
*/
virtual void resetEntities();
@@ -1034,7 +1034,7 @@
* This method is used to indicate the start of parsing an external
* entity file.
*
- * <b><font color="#FF0000">This method is a no-op for this IDOM parse
+ * <b><font color="#FF0000">This method is a no-op for this DOM parse
* implementation.</font></b>
*
* @param inputSource A const reference to the InputSource object
@@ -1057,8 +1057,8 @@
/** Handle document character events
*
* This method is used to report all the characters scanned by the
- * parser. This IDOM implementation stores this data in the appropriate
- * IDOM node, creating one if necessary.
+ * parser. This DOM implementation stores this data in the appropriate
+ * DOM node, creating one if necessary.
*
* @param chars A const pointer to a Unicode string representing the
* character data.
@@ -1113,7 +1113,7 @@
/** Handle and end of element event
*
* This method is used to indicate the end tag of an element. The
- * IDOMParse pops the current element off the top of the element
+ * DOMParse pops the current element off the top of the element
* stack, and make it the new current element.
*
* @param elemDecl A const reference to the object containing element
@@ -1150,7 +1150,7 @@
* is only made, if validation is enabled.
*
* Any whitespace before content is ignored. If the current node is
- * already of type IDOM_Node::TEXT_NODE, then these whitespaces are
+ * already of type DOMNode::TEXT_NODE, then these whitespaces are
* appended, otherwise a new Text node is created which stores this
* data. Essentially all contiguous ignorable characters are collected
* in one node.
@@ -1186,7 +1186,7 @@
*
* This method is used to report the start of an element. It is
* called at the end of the element, by which time all attributes
- * specified are also parsed. A new IDOM Element node is created
+ * specified are also parsed. A new DOM Element node is created
* along with as many attribute nodes as required. This new element
* is added appended as a child of the current node in the tree, and
* then replaces it as the current node (if the isEmpty flag is false.)
@@ -1224,7 +1224,7 @@
*
* This method is used to indicate the start of an entity reference.
* If the expand entity reference flag is true, then a new
- * IDOM Entity reference node is created.
+ * DOM Entity reference node is created.
*
* @param entDecl A const reference to the object containing the
* entity declaration information.
@@ -1239,7 +1239,7 @@
* This method is used to report the XML decl scanned by the parser.
* Refer to the XML specification to see the meaning of parameters.
*
- * <b><font color="#FF0000">This method is a no-op for this IDOM
+ * <b><font color="#FF0000">This method is a no-op for this DOM
* implementation.</font></b>
*
* @param versionStr A const pointer to a Unicode string representing
@@ -1382,12 +1382,12 @@
/** @name Protected getter methods */
//@{
- /** Get the current IDOM node
+ /** Get the current DOM node
*
* This provides derived classes with access to the current node, i.e.
* the node to which new nodes are being added.
*/
- IDOM_Node* getCurrentNode();
+ DOMNode* getCurrentNode();
//@}
@@ -1399,28 +1399,28 @@
/** @name Protected setter methods */
//@{
- /** Set the current IDOM node
+ /** Set the current DOM node
*
* This method sets the current node maintained inside the parser to
* the one specified.
*
- * @param toSet The IDOM node which will be the current node.
+ * @param toSet The DOM node which will be the current node.
*/
- void setCurrentNode(IDOM_Node* toSet);
+ void setCurrentNode(DOMNode* toSet);
/** Set the document node
*
- * This method sets the IDOM Document node to the one specified.
+ * This method sets the DOM Document node to the one specified.
*
- * @param toSet The new IDOM Document node for this XML document.
+ * @param toSet The new DOM Document node for this XML document.
*/
- void setDocument(IDOM_Document* toSet);
+ void setDocument(DOMDocument* toSet);
//@}
// -----------------------------------------------------------------------
// Protected Helper methods
// -----------------------------------------------------------------------
- virtual IDOM_Element* createElementNSNode(const XMLCh *fNamespaceURI,
+ virtual DOMElement* createElementNSNode(const XMLCh *fNamespaceURI,
const XMLCh *qualifiedName);
@@ -1458,7 +1458,7 @@
//
// fIncludeIgnorableWhitespace
// Indicates whether ignorable whiltespace should be added to
- // the IDOM tree for validating parsers.
+ // the DOM tree for validating parsers.
//
// fNodeStack
// Used to track previous parent nodes during nested element events.
@@ -1483,124 +1483,124 @@
// Store all the previous fDocument(s) (thus not the current fDocument)
// created in this parser. It is destroyed when the parser is destructed.
// -----------------------------------------------------------------------
- IDOM_Node* fCurrentParent;
- IDOM_Node* fCurrentNode;
- IDDocumentImpl* fDocument;
+ DOMNode* fCurrentParent;
+ DOMNode* fCurrentNode;
+ DOMDocumentImpl* fDocument;
EntityResolver* fEntityResolver;
ErrorHandler* fErrorHandler;
bool fCreateEntityReferenceNodes;
bool fIncludeIgnorableWhitespace;
- ValueStackOf<IDOM_Node*>* fNodeStack;
+ ValueStackOf<DOMNode*>* fNodeStack;
bool fParseInProgress;
bool fWithinElement;
- IDDocumentTypeImpl* fDocumentType;
- RefVectorOf<IDDocumentImpl>* fDocumentVector;
+ DOMDocumentTypeImpl* fDocumentType;
+ RefVectorOf<DOMDocumentImpl>* fDocumentVector;
};
// ---------------------------------------------------------------------------
-// IDOMParser: Handlers for the XMLEntityHandler interface
+// XercesDOMParser: Handlers for the XMLEntityHandler interface
// ---------------------------------------------------------------------------
-inline void IDOMParser::endInputSource(const InputSource&)
+inline void XercesDOMParser::endInputSource(const InputSource&)
{
- // The IDOM entity resolver doesn't handle this
+ // The DOM entity resolver doesn't handle this
}
-inline bool IDOMParser::expandSystemId(const XMLCh* const, XMLBuffer&)
+inline bool XercesDOMParser::expandSystemId(const XMLCh* const, XMLBuffer&)
{
- // The IDOM entity resolver doesn't handle this
+ // The DOM entity resolver doesn't handle this
return false;
}
-inline void IDOMParser::resetEntities()
+inline void XercesDOMParser::resetEntities()
{
// Nothing to do on this one
}
-inline void IDOMParser::startInputSource(const InputSource&)
+inline void XercesDOMParser::startInputSource(const InputSource&)
{
- // The IDOM entity resolver doesn't handle this
+ // The DOM entity resolver doesn't handle this
}
// ---------------------------------------------------------------------------
-// IDOMParser: Getter methods
+// XercesDOMParser: Getter methods
// ---------------------------------------------------------------------------
-inline ErrorHandler* IDOMParser::getErrorHandler()
+inline ErrorHandler* XercesDOMParser::getErrorHandler()
{
return fErrorHandler;
}
-inline const ErrorHandler* IDOMParser::getErrorHandler() const
+inline const ErrorHandler* XercesDOMParser::getErrorHandler() const
{
return fErrorHandler;
}
-inline EntityResolver* IDOMParser::getEntityResolver()
+inline EntityResolver* XercesDOMParser::getEntityResolver()
{
return fEntityResolver;
}
-inline const EntityResolver* IDOMParser::getEntityResolver() const
+inline const EntityResolver* XercesDOMParser::getEntityResolver() const
{
return fEntityResolver;
}
-inline bool IDOMParser::getExpandEntityReferences() const
+inline bool XercesDOMParser::getExpandEntityReferences() const
{
return !fCreateEntityReferenceNodes;
}
-inline bool IDOMParser::getCreateEntityReferenceNodes() const
+inline bool XercesDOMParser::getCreateEntityReferenceNodes() const
{
return fCreateEntityReferenceNodes;
}
-inline bool IDOMParser::getIncludeIgnorableWhitespace() const
+inline bool XercesDOMParser::getIncludeIgnorableWhitespace() const
{
return fIncludeIgnorableWhitespace;
}
// ---------------------------------------------------------------------------
-// IDOMParser: Setter methods
+// XercesDOMParser: Setter methods
// ---------------------------------------------------------------------------
-inline void IDOMParser::setExpandEntityReferences(const bool expand)
+inline void XercesDOMParser::setExpandEntityReferences(const bool expand)
{
fCreateEntityReferenceNodes = !expand;
}
-inline void IDOMParser::setCreateEntityReferenceNodes(const bool create)
+inline void XercesDOMParser::setCreateEntityReferenceNodes(const bool create)
{
fCreateEntityReferenceNodes = create;
}
-inline void IDOMParser::setIncludeIgnorableWhitespace(const bool include)
+inline void XercesDOMParser::setIncludeIgnorableWhitespace(const bool include)
{
fIncludeIgnorableWhitespace = include;
}
// ---------------------------------------------------------------------------
-// IDOMParser: Protected getter methods
+// XercesDOMParser: Protected getter methods
// ---------------------------------------------------------------------------
-inline IDOM_Node* IDOMParser::getCurrentNode()
+inline DOMNode* XercesDOMParser::getCurrentNode()
{
return fCurrentNode;
}
// ---------------------------------------------------------------------------
-// IDOMParser: Protected setter methods
+// XercesDOMParser: Protected setter methods
// ---------------------------------------------------------------------------
-inline void IDOMParser::setCurrentNode(IDOM_Node* toSet)
+inline void XercesDOMParser::setCurrentNode(DOMNode* toSet)
{
fCurrentNode = toSet;
}
-inline void IDOMParser::setDocument(IDOM_Document* toSet)
+inline void XercesDOMParser::setDocument(DOMDocument* toSet)
{
- fDocument = (IDDocumentImpl *)toSet;
+ fDocument = (DOMDocumentImpl*)toSet;
}
#endif
---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org