---

IDOMParser Class Reference

Inheritance diagram for IDOMParser:

List of all members.

Public Types
enum	ValSchemes { Val_Never, Val_Always, Val_Auto }
Public Methods
void	reset ()
void	resetDocumentPool ()
Constructors and Destructor
	IDOMParser (XMLValidator *const valToAdopt=0)
	~IDOMParser ()
Getter methods
IDOM_Document *	getDocument ()
ErrorHandler *	getErrorHandler ()
const ErrorHandler *	getErrorHandler () const
EntityResolver *	getEntityResolver ()
const EntityResolver *	getEntityResolver () const
const XMLValidator &	getValidator () const
ValSchemes	getValidationScheme () const
bool	getDoSchema () const
bool	getValidationSchemaFullChecking () const
int	getErrorCount () const
bool	getDoNamespaces () const
bool	getExitOnFirstFatalError () const
bool	getValidationConstraintFatal () const
bool	getExpandEntityReferences () const
bool	getCreateEntityReferenceNodes () const
bool	getIncludeIgnorableWhitespace () const
XMLCh *	getExternalSchemaLocation () const
XMLCh *	getExternalNoNamespaceSchemaLocation () const
bool	getURLEntityCaching () const
XMLCh *	getURLEntityCacheDir () const
Setter methods
void	setErrorHandler (ErrorHandler *const handler)
void	setEntityResolver (EntityResolver *const handler)
void	setDoNamespaces (const bool newState)
void	setExitOnFirstFatalError (const bool newState)
void	setValidationConstraintFatal (const bool newState)
void	setExpandEntityReferences (const bool expand)
void	setCreateEntityReferenceNodes (const bool create)
void	setIncludeIgnorableWhitespace (const bool include)
void	setValidationScheme (const ValSchemes newScheme)
void	setDoSchema (const bool newState)
void	setValidationSchemaFullChecking (const bool schemaFullChecking)
void	setExternalSchemaLocation (const XMLCh *const schemaLocation)
void	setExternalSchemaLocation (const char *const schemaLocation)
void	setExternalNoNamespaceSchemaLocation (const XMLCh *const noNamespaceSchemaLocation)
void	setExternalNoNamespaceSchemaLocation (const char *const noNamespaceSchemaLocation)
void	setURLEntityCaching (const bool useCache)
void	setURLEntityCacheDir (const XMLCh *cachedir)
void	setURLEntityCacheDir (const char *cachedir)
Parsing methods
void	parse (const InputSource &source, const bool reuseGrammar=false)
void	parse (const XMLCh *const systemId, const bool reuseGrammar=false)
void	parse (const char *const systemId, const bool reuseGrammar=false)
bool	parseFirst (const XMLCh *const systemId, XMLPScanToken &toFill, const bool reuseGrammar=false)
bool	parseFirst (const char *const systemId, XMLPScanToken &toFill, const bool reuseGrammar=false)
bool	parseFirst (const InputSource &source, XMLPScanToken &toFill, const bool reuseGrammar=false)
bool	parseNext (XMLPScanToken &token)
void	parseReset (XMLPScanToken &token)
Implementation of the XMLErrorReporter interface.
virtual void	error (const unsigned int errCode, const XMLCh *const msgDomain, const XMLErrorReporter::ErrTypes errType, const XMLCh *const errorText, const XMLCh *const systemId, const XMLCh *const publicId, const unsigned int lineNum, const unsigned int colNum)
virtual void	resetErrors ()
Implementation of the XMLEntityHandler interface.
virtual void	endInputSource (const InputSource &inputSource)
virtual bool	expandSystemId (const XMLCh *const systemId, XMLBuffer &toFill)
virtual void	resetEntities ()
virtual InputSource *	resolveEntity (const XMLCh *const publicId, const XMLCh *const systemId)
virtual void	startInputSource (const InputSource &inputSource)
Implementation of the XMLDocumentHandler interface.
virtual void	docCharacters (const XMLCh *const chars, const unsigned int length, const bool cdataSection)
virtual void	docComment (const XMLCh *const comment)
virtual void	docPI (const XMLCh *const target, const XMLCh *const data)
virtual void	endDocument ()
virtual void	endElement (const XMLElementDecl &elemDecl, const unsigned int urlId, const bool isRoot)
virtual void	endEntityReference (const XMLEntityDecl &entDecl)
virtual void	ignorableWhitespace (const XMLCh *const chars, const unsigned int length, const bool cdataSection)
virtual void	resetDocument ()
virtual void	startDocument ()
virtual void	startElement (const XMLElementDecl &elemDecl, const unsigned int urlId, const XMLCh *const elemPrefix, const RefVectorOf< XMLAttr > &attrList, const unsigned int attrCount, const bool isEmpty, const bool isRoot)
virtual void	startEntityReference (const XMLEntityDecl &entDecl)
virtual void	XMLDecl (const XMLCh *const versionStr, const XMLCh *const encodingStr, const XMLCh *const standaloneStr, const XMLCh *const actualEncStr)
Deprecated Methods
bool	getDoValidation () const
void	setDoValidation (const bool newState)
virtual void	attDef (const DTDElementDecl &elemDecl, const DTDAttDef &attDef, const bool ignoring)
virtual void	doctypeComment (const XMLCh *const comment)
virtual void	doctypeDecl (const DTDElementDecl &elemDecl, const XMLCh *const publicId, const XMLCh *const systemId, const bool hasIntSubset)
virtual void	doctypePI (const XMLCh *const target, const XMLCh *const data)
virtual void	doctypeWhitespace (const XMLCh *const chars, const unsigned int length)
virtual void	elementDecl (const DTDElementDecl &decl, const bool isIgnored)
virtual void	endAttList (const DTDElementDecl &elemDecl)
virtual void	endIntSubset ()
virtual void	endExtSubset ()
virtual void	entityDecl (const DTDEntityDecl &entityDecl, const bool isPEDecl, const bool isIgnored)
virtual void	resetDocType ()
virtual void	notationDecl (const XMLNotationDecl &notDecl, const bool isIgnored)
virtual void	startAttList (const DTDElementDecl &elemDecl)
virtual void	startIntSubset ()
virtual void	startExtSubset ()
virtual void	TextDecl (const XMLCh *const versionStr, const XMLCh *const encodingStr)
Protected Methods
Protected getter methods
IDOM_Node *	getCurrentNode ()
Protected setter methods
void	setCurrentNode (IDOM_Node *toSet)
void	setDocument (IDOM_Document *toSet)

---

Detailed Description

This class implements the Document Object Model (DOM) interface. It should be used by applications which choose to parse and process the XML document using the DOM api's. This implementation also allows the applications to install an error and an entitty handler (useful extensions to the DOM specification).

It can be used to instantiate a validating or non-validating parser, by setting a member flag.

---

Constructor & Destructor Documentation

IDOMParser::IDOMParser (  XMLValidator *const    valToAdopt = 0 )

Construct a IDOMParser, 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 be created for you in the scanner. Parameters: valToAdopt  Pointer to the validator instance to use. The parser is responsible for freeing the memory.

IDOMParser::~IDOMParser (    )

Destructor

---

Member Function Documentation

void IDOMParser::attDef (  const DTDElementDecl &    elemDecl, const DTDAttDef &    attDef, const bool    ignoring )  [virtual]

Deprecated doctypehandler interfaces

void IDOMParser::docCharacters (  const XMLCh *const    chars, const unsigned int    length, const bool    cdataSection )  [virtual]

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. Parameters: chars  A const pointer to a Unicode string representing the character data. length  The length of the Unicode string returned in 'chars'. cdataSection  A flag indicating if the characters represent content from the CDATA section. Implements XMLDocumentHandler.

void IDOMParser::docComment (  const XMLCh *const    comment )  [virtual]

Handle a document comment event This method is used to report any comments scanned by the parser. A new comment node is created which stores this data. Parameters: comment  A const pointer to a null terminated Unicode string representing the comment text. Implements XMLDocumentHandler.

void IDOMParser::docPI (  const XMLCh *const    target, const XMLCh *const    data )  [virtual]

Handle a document PI event This method is used to report any PI scanned by the parser. A new PI node is created and appended as a child of the current node in the tree. Parameters: target  A const pointer to a Unicode string representing the target of the PI declaration. data  A const pointer to a Unicode string representing the data of the PI declaration. See the PI production rule in the XML specification for details. Implements XMLDocumentHandler.

void IDOMParser::endDocument (    )  [virtual]

Handle the end of document event This method is used to indicate the end of the current document. Implements XMLDocumentHandler.

void IDOMParser::endElement (  const XMLElementDecl &    elemDecl, const unsigned int    urlId, const bool    isRoot )  [virtual]

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 stack, and make it the new current element. Parameters: elemDecl  A const reference to the object containing element declaration information. urlId  An id referring to the namespace prefix, if namespaces setting is switched on. isRoot  A flag indicating whether this element was the root element. Implements XMLDocumentHandler.

void IDOMParser::endEntityReference (  const XMLEntityDecl &    entDecl )  [virtual]

Handle and end of entity reference event This method is used to indicate that an end of an entity reference was just scanned. Parameters: entDecl  A const reference to the object containing the entity declaration information. Implements XMLDocumentHandler.

void IDOMParser::endInputSource (  const InputSource &    inputSource )  [inline, virtual]

Handle an end of input source event This method is used to indicate the end of parsing of an external entity file. This method is a no-op for this IDOM implementation. Parameters: inputSource  A const reference to the InputSource object which points to the XML file being parsed. See also: InputSource Implements XMLEntityHandler.

void IDOMParser::error (  const unsigned int    errCode, const XMLCh *const    msgDomain, const XMLErrorReporter::ErrTypes    errType, const XMLCh *const    errorText, const XMLCh *const    systemId, const XMLCh *const    publicId, const unsigned int    lineNum, const unsigned int    colNum )  [virtual]

Handle errors reported from the parser This method is used to report back errors found while parsing the XML file. This method is also borrowed from the SAX specification. It calls the corresponding user installed Error Handler method: 'fatal', 'error', 'warning' depending on the severity of the error. This classification is defined by the XML specification. Parameters: errCode  An integer code for the error. msgDomain  A const pointer to an Unicode string representing the message domain to use. errType  An enumeration classifying the severity of the error. errorText  A const pointer to an Unicode string representing the text of the error message. systemId  A const pointer to an Unicode string representing the system id of the XML file where this error was discovered. publicId  A const pointer to an Unicode string representing the public id of the XML file where this error was discovered. lineNum  The line number where the error occurred. colNum  The column number where the error occurred. See also: ErrorHandler

bool IDOMParser::expandSystemId (  const XMLCh *const    systemId, XMLBuffer &    toFill )  [inline, virtual]

Expand a system id This method allows an installed XMLEntityHandler to further process any system id's of enternal entities encountered in the XML file being parsed, such as redirection etc. This method always returns 'false' for this IDOM implementation. Parameters: systemId  A const pointer to an Unicode string representing the system id scanned by the parser. toFill  A pointer to a buffer in which the application processed system id is stored. Returns: 'true', if any processing is done, 'false' otherwise. Implements XMLEntityHandler.

bool IDOMParser::getCreateEntityReferenceNodes (    )  const [inline]

Get the 'include entity references' flag This flag specifies whether the parser is creating entity reference nodes in the DOM tree being produced. When the 'create' flag is true, the DOM tree will contain entity reference nodes. When the 'create' flag is false, no entity reference nodes are included in the DOM tree. The replacement text of the entity is included in either case, either as a child of the Entity Reference node or in place at the location of the reference. Returns: The state of the create entity reference node flag. See also: setCreateEntityReferenceNodes

IDOM_Node * IDOMParser::getCurrentNode (    )  [inline, protected]

Get the current IDOM node This provides derived classes with access to the current node, i.e. the node to which new nodes are being added.

IDOM_Document * IDOMParser::getDocument (    )

Get the IDOM document This method returns the IDOM_Document object representing the root of the document tree. This object provides the primary access to the document's data. Returns: The IDOM_Document object which represents the entire XML document.

bool IDOMParser::getDoNamespaces (    )  const

Get the 'do namespaces' flag This method returns the state of the parser's namespace processing flag. Returns: true, if the parser is currently configured to understand namespaces, false otherwise. See also: setDoNamespaces

bool IDOMParser::getDoSchema (    )  const

Get the 'do schema' flag This method returns the state of the parser's schema processing flag. Returns: true, if the parser is currently configured to understand schema, false otherwise. See also: setDoSchema

bool IDOMParser::getDoValidation (    )  const

This method returns the state of the parser's validation handling flag which controls whether validation checks are enforced or not. Returns: true, if the parser is currently configured to do validation, false otherwise. See also: setDoValidation

const EntityResolver * IDOMParser::getEntityResolver (    )  const [inline]

Get a const pointer to the entity resolver This method returns the installed entity resolver. If no resolver has been installed, then it will be a zero pointer. Returns: A const pointer to the installed entity resolver object.

EntityResolver * IDOMParser::getEntityResolver (    )  [inline]

Get a pointer to the entity resolver This method returns the installed entity resolver. If no resolver has been installed, then it will be a zero pointer. Returns: The pointer to the installed entity resolver object.

int IDOMParser::getErrorCount (    )  const

Get error count from the last parse operation. This method returns the error count from the last parse operation. Note that this count is actually stored in the scanner, so this method simply returns what the scanner reports. Returns: number of errors encountered during the latest parse operation.

const ErrorHandler * IDOMParser::getErrorHandler (    )  const [inline]

Get a const pointer to the error handler This method returns the installed error handler. If no handler has been installed, then it will be a zero pointer. Returns: A const pointer to the installed error handler object.

ErrorHandler * IDOMParser::getErrorHandler (    )  [inline]

Get a pointer to the error handler This method returns the installed error handler. If no handler has been installed, then it will be a zero pointer. Returns: The pointer to the installed error handler object.

bool IDOMParser::getExitOnFirstFatalError (    )  const

Get the 'exit on first error' flag This method returns the state of the parser's exit-on-First-Fatal-Error flag. If this flag is true, then the parse will exit the first time it sees any non-wellformed XML or any validity error. The default state is true. Returns: true, if the parser is currently configured to exit on the first fatal error, false otherwise. See also: setExitOnFirstFatalError

bool IDOMParser::getExpandEntityReferences (    )  const [inline]

Get the 'expand entity references' flag. DEPRECATED Use getCreateEntityReferenceNodes() instead. This method returns the state of the parser's expand entity references flag. Returns: 'true' if the expand entity reference flag is set on the parser, 'false' otherwise. See also: setExpandEntityReferences

XMLCh * IDOMParser::getExternalNoNamespaceSchemaLocation (    )  const

Get the noNamespace SchemaLocation that is specified externaly. This method returns the no target namespace XML Schema Location that was specified using setExternalNoNamespaceSchemaLocation. The parser owns the returned string, and the memory allocated for the returned string will be destroyed when the parser is deleted. To ensure assessiblity of the returned information after the parser is deleted, callers need to copy and store the returned information somewhere else. Returns: a pointer to the no target namespace Schema Location that was specified externally. The pointer spans the same life-time as the parser. A null pointer is returned if nothing was specified externally. See also: setExternalNoNamespaceSchemaLocation(const XMLCh* const)

XMLCh * IDOMParser::getExternalSchemaLocation (    )  const

Get the set of Namespace/SchemaLocation that is specified externaly. This method returns the list of Namespace/SchemaLocation that was specified using setExternalSchemaLocation. The parser owns the returned string, and the memory allocated for the returned string will be destroyed when the parser is deleted. To ensure assessiblity of the returned information after the parser is deleted, callers need to copy and store the returned information somewhere else. Returns: a pointer to the list of Namespace/SchemaLocation that was specified externally. The pointer spans the same life-time as the parser. A null pointer is returned if nothing was specified externally. See also: setExternalSchemaLocation(const XMLCh* const)

bool IDOMParser::getIncludeIgnorableWhitespace (    )  const [inline]

Get the 'include ignorable whitespace' flag. This method returns the state of the parser's include ignorable whitespace flag. Returns: 'true' if the include ignorable whitespace flag is set on the parser, 'false' otherwise. See also: setIncludeIgnorableWhitespace

XMLCh * IDOMParser::getURLEntityCacheDir (    )  const

This method returns the absolute directory path where the entity files are cached. Returns: a pointer to the location where the entity file are cached. A NULL pointer is returned if no location was specified. See also: setURLEntityCacheDir

bool IDOMParser::getURLEntityCaching (    )  const

This method returns the state of the parser's entity file caching capability. Returns: true if the parser is currently configured to cache the external entity files. See also: setURLEntityCaching

bool IDOMParser::getValidationConstraintFatal (    )  const

This method returns the state of the parser's validation-constraint-fatal flag. Returns: true, if the parser is currently configured to set validation constraint errors as fatal, false otherwise. See also: #setValidationContraintFatal

bool IDOMParser::getValidationSchemaFullChecking (    )  const

Get the 'full schema constraint checking' flag This method returns the state of the parser's full schema constraint checking flag. Returns: true, if the parser is currently configured to have full schema constraint checking, false otherwise. See also: setValidationSchemaFullChecking

IDOMParser::ValSchemes IDOMParser::getValidationScheme (    )  const

This method returns an enumerated value that indicates the current validation scheme set on this parser. Returns: The ValSchemes value current set on this parser. See also: setValidationScheme

const XMLValidator & IDOMParser::getValidator (    )  const

Get a const reference to the validator This method returns a reference to the parser's installed validator. Returns: A const reference to the installed validator object.

void IDOMParser::ignorableWhitespace (  const XMLCh *const    chars, const unsigned int    length, const bool    cdataSection )  [virtual]

Handle an ignorable whitespace vent This method is used to report all the whitespace characters, which are determined to be 'ignorable'. This distinction between characters 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 appended, otherwise a new Text node is created which stores this data. Essentially all contiguous ignorable characters are collected in one node. Parameters: chars  A const pointer to a Unicode string representing the ignorable whitespace character data. length  The length of the Unicode string 'chars'. cdataSection  A flag indicating if the characters represent content from the CDATA section. Implements XMLDocumentHandler.

void IDOMParser::parse (  const char *const    systemId, const bool    reuseGrammar = false )

Parse via a file path or URL (in the local code page) This method invokes the parsing process on the XML file specified by the native char* string parameter 'systemId'. Parameters: systemId  A const char pointer to a native string which contains the path to the XML file to be parsed. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing run. If true, there cannot be any internal subset. Exceptions: SAXException  Any SAX exception, possibly wrapping another exception. XMLException  An exception from the parser or client handler code. DOM_DOMException  A DOM exception as per DOM spec. See also: parse(InputSource,...)

void IDOMParser::parse (  const XMLCh *const    systemId, const bool    reuseGrammar = false )

Parse via a file path or URL This method invokes the parsing process on the XML file specified by the Unicode string parameter 'systemId'. This method is borrowed from the SAX Parser interface. Parameters: systemId  A const XMLCh pointer to the Unicode string which contains the path to the XML file to be parsed. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing run. If true, there cannot be any internal subset. Exceptions: SAXException  Any SAX exception, possibly wrapping another exception. XMLException  An exception from the parser or client handler code. DOM_DOMException  A DOM exception as per DOM spec. See also: parse(InputSource,...)

void IDOMParser::parse (  const InputSource &    source, const bool    reuseGrammar = false )

Parse via an input source object This method invokes the parsing process on the XML file specified by the InputSource parameter. This API is borrowed from the SAX Parser interface. Parameters: source  A const reference to the InputSource object which points to the XML file to be parsed. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing run. If true, there cannot be any internal subset. Exceptions: SAXException  Any SAX exception, possibly wrapping another exception. XMLException  An exception from the parser or client handler code. IDOM_DOMException  A DOM exception as per DOM spec. See also: InputSource#InputSource setEntityResolver setErrorHandler

bool IDOMParser::parseFirst (  const InputSource &    source, XMLPScanToken &    toFill, const bool    reuseGrammar = false )

Begin a progressive parse operation This method is used to start a progressive parse on a XML file. To continue parsing, subsequent calls must be to the parseNext method. It scans through the prolog and returns a token to be used on subsequent scanNext() calls. If the return value is true, then the token is legal and ready for further use. If it returns false, then the scan of the prolog failed and the token is not going to work on subsequent scanNext() calls. Parameters: source  A const reference to the InputSource object which points to the XML file to be parsed. toFill  A token maintaing state information to maintain internal consistency between invocation of 'parseNext' calls. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing process. If true, there cannot be any internal subset. Returns: 'true', if successful in parsing the prolog. It indicates the user can go ahead with parsing the rest of the file. It returns 'false' to indicate that the parser could not parse the prolog. See also: parseNext parseFirst(XMLCh*,...) parseFirst(char*,...)

bool IDOMParser::parseFirst (  const char *const    systemId, XMLPScanToken &    toFill, const bool    reuseGrammar = false )

Begin a progressive parse operation This method is used to start a progressive parse on a XML file. To continue parsing, subsequent calls must be to the parseNext method. It scans through the prolog and returns a token to be used on subsequent scanNext() calls. If the return value is true, then the token is legal and ready for further use. If it returns false, then the scan of the prolog failed and the token is not going to work on subsequent scanNext() calls. Parameters: systemId  A pointer to a regular native string represting the path to the XML file to be parsed. toFill  A token maintaing state information to maintain internal consistency between invocation of 'parseNext' calls. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing run. If true, there cannot be any internal subset. Returns: 'true', if successful in parsing the prolog. It indicates the user can go ahead with parsing the rest of the file. It returns 'false' to indicate that the parser could not parse the prolog. See also: parseNext parseFirst(XMLCh*,...) parseFirst(InputSource&,...)

bool IDOMParser::parseFirst (  const XMLCh *const    systemId, XMLPScanToken &    toFill, const bool    reuseGrammar = false )

Begin a progressive parse operation This method is used to start a progressive parse on a XML file. To continue parsing, subsequent calls must be to the parseNext method. It scans through the prolog and returns a token to be used on subsequent scanNext() calls. If the return value is true, then the token is legal and ready for further use. If it returns false, then the scan of the prolog failed and the token is not going to work on subsequent scanNext() calls. Parameters: systemId  A pointer to a Unicode string represting the path to the XML file to be parsed. toFill  A token maintaing state information to maintain internal consistency between invocation of 'parseNext' calls. reuseGrammar  The flag indicating whether the existing Grammar should be reused or not for this parsing process. If true, there cannot be any internal subset. Returns: 'true', if successful in parsing the prolog. It indicates the user can go ahead with parsing the rest of the file. It returns 'false' to indicate that the parser could not parse the prolog. See also: parseNext parseFirst(char*,...) parseFirst(InputSource&,...)

bool IDOMParser::parseNext (  XMLPScanToken &    token )

Continue a progressive parse operation This method is used to continue with progressive parsing of XML files started by a call to 'parseFirst' method. It parses the XML file and stops as soon as it comes across a XML token (as defined in the XML specification). Parameters: token  A token maintaing state information to maintain internal consistency between invocation of 'parseNext' calls. Returns: 'true', if successful in parsing the next XML token. It indicates the user can go ahead with parsing the rest of the file. It returns 'false' to indicate that the parser could not find next token as per the XML specification production rule. See also: parseFirst(XMLCh*,...) parseFirst(char*,...) parseFirst(InputSource&,...)

void IDOMParser::parseReset (  XMLPScanToken &    token )

Reset the parser after a progressive parse If a progressive parse loop exits before the end of the document is reached, the parser has no way of knowing this. So it will leave open any files or sockets or memory buffers that were in use at the time that the parse loop exited. The next parse operation will cause these open files and such to be closed, but the next parse operation might occur at some unknown future point. To avoid this problem, you should reset the parser if you exit the loop early. If you exited because of an error, then this cleanup will be done for you. Its only when you exit the file prematurely of your own accord, because you've found what you wanted in the file most likely. Parameters: token  A token maintaing state information to maintain internal consistency between invocation of 'parseNext' calls. See also: parseFirst(XMLCh*,...) parseFirst(char*,...) parseFirst(InputSource&,...)

void IDOMParser::reset (    )

Reset the parser This method resets the state of the IDOM driver and makes it ready for a fresh parse run.

void IDOMParser::resetDocument (    )  [virtual]

Handle a document reset event This method allows the user installed Document Handler to 'reset' itself, freeing all the memory resources. The scanner calls this method before starting a new parse event. Implements XMLDocumentHandler.

void IDOMParser::resetDocumentPool (    )

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 for a DOM tree is associated to the DOM document. If you do multiple parse using the same IDOMParser 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 to reset the document vector pool and release all the allocated memory back to the system. It is an error to call this method if you are in the middle of a parse (e.g. in the mid of a progressive parse). Exceptions: IOException  An exception from the parser if this function is called when a parse is in progress.

void IDOMParser::resetEntities (    )  [inline, virtual]

Reset any entity handler information This method allows the installed XMLEntityHandler to reset itself. This method is a no-op for this IDOM implementation. Implements XMLEntityHandler.

void IDOMParser::resetErrors (    )  [virtual]

Reset any error data before a new parse This method allows the user installed Error Handler callback to 'reset' itself. This method is a no-op for this IDOM implementation. Implements XMLErrorReporter.

InputSource * IDOMParser::resolveEntity (  const XMLCh *const    publicId, const XMLCh *const    systemId )  [virtual]

Resolve a public/system id This method allows a user installed entity handler to further process any pointers to external entities. The applications can implement 'redirection' via this callback. This method is also borrowed from the SAX specification. Parameters: publicId  A const pointer to a Unicode string representing the public id of the entity just parsed. systemId  A const pointer to a Unicode string representing the system id of the entity just parsed. Returns: The value returned by the user installed resolveEntity method or NULL otherwise to indicate no processing was done. See also: EntityResolver Implements XMLEntityHandler.

void IDOMParser::setCreateEntityReferenceNodes (  const bool    create )  [inline]

Set the 'include entity references' flag This method allows the user to specify whether the parser should create entity reference nodes in the DOM tree being produced. When the 'create' flag is true, the DOM tree constains entity reference nodes. When the 'create' flag is false, no entity reference nodes are included in the DOM tree. The replacement text of the entity is included in either case, either as a child of the Entity Reference node or in place at the location of the reference. Parameters: create  The new state of the create entity reference nodes flag.

void IDOMParser::setCurrentNode (  IDOM_Node *    toSet )  [inline, protected]

Set the current IDOM node This method sets the current node maintained inside the parser to the one specified. Parameters: toSet  The IDOM node which will be the current node.

void IDOMParser::setDocument (  IDOM_Document *    toSet )  [inline, protected]

Set the document node This method sets the IDOM Document node to the one specified. Parameters: toSet  The new IDOM Document node for this XML document.

void IDOMParser::setDoNamespaces (  const bool    newState )

Set the 'do namespaces' flag This method allows users to enable or disable the parser's namespace processing. When set to true, parser starts enforcing all the constraints and rules specified by the NameSpace specification. The parser's default state is: false. This flag is ignored by the underlying scanner if the installed validator indicates that namespace constraints should be enforced. Parameters: newState  The value specifying whether NameSpace rules should be enforced or not. See also: getDoNamespaces

void IDOMParser::setDoSchema (  const bool    newState )

Set the 'do schema' flag This method allows users to enable or disable the parser's schema processing. When set to false, parser will not process any schema found. The parser's default state is: false. Parameters: newState  The value specifying whether schema support should be enforced or not. See also: getDoSchema

void IDOMParser::setDoValidation (  const bool    newState )

This method allows users to enable or disable the parser's validation checks. By default, the parser does not to any validation. The default value is false. Parameters: newState  The value specifying whether the parser should do validity checks or not against the DTD in the input XML document. See also: getDoValidation

void IDOMParser::setEntityResolver (  EntityResolver *const    handler )

Set the entity resolver This method allows applications to install their own entity resolver. By installing an entity resolver, the applications can trap and potentially redirect references to external entities. Any previously set resolver is merely dropped, since the parser does not own them. Parameters: handler  A const pointer to the user supplied entity resolver. See also: getEntityResolver

void IDOMParser::setErrorHandler (  ErrorHandler *const    handler )

Set the error handler This method allows applications to install their own error handler to trap error and warning messages. Any previously set handler is merely dropped, since the parser does not own them. Parameters: handler  A const pointer to the user supplied error handler. See also: getErrorHandler

void IDOMParser::setExitOnFirstFatalError (  const bool    newState )

Set the 'exit on first error' flag This method allows users to set the parser's behaviour when it encounters the first fatal error. If set to true, the parser will exit at the first fatal error. If false, then it will report the error and continue processing. The default value is 'true' and the parser exits on the first fatal error. Parameters: newState  The value specifying whether the parser should continue or exit when it encounters the first fatal error. See also: getExitOnFirstFatalError

void IDOMParser::setExpandEntityReferences (  const bool    expand )  [inline]

Set the 'expand entity references' flag DEPRECATED. USE setCreateEntityReferenceNodes instead. This method allows the user to specify whether the parser should expand all entity reference nodes. When the 'do expansion' flag is true, the DOM tree does not have any entity reference nodes. It is replaced by the sub-tree representing the replacement text of the entity. When the 'do expansion' flag is false, the DOM tree contains an extra entity reference node, whose children is the sub tree of the replacement text. Parameters: expand  The new state of the expand entity reference flag.

void IDOMParser::setExternalNoNamespaceSchemaLocation (  const char *const    noNamespaceSchemaLocation )

This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const). It takes native char string as parameter Parameters: noNamespaceSchemaLocation  the XML Schema Location with no target namespace See also: setExternalNoNamespaceSchemaLocation(const XMLCh* const)

void IDOMParser::setExternalNoNamespaceSchemaLocation (  const XMLCh *const    noNamespaceSchemaLocation )

This method allows the user to specify the no target namespace XML Schema Location externally. If specified, the instance document's noNamespaceSchemaLocation attribute will be effectively ignored. If this method is called more than once, only the last one takes effect. The syntax is the same as for the noNamespaceSchemaLocation attribute that may occur in an instance document: e.g."file_name.xsd". Parameters: noNamespaceSchemaLocation  the XML Schema Location with no target namespace See also: getExternalNoNamespaceSchemaLocation

void IDOMParser::setExternalSchemaLocation (  const char *const    schemaLocation )

This method is same as setExternalSchemaLocation(const XMLCh* const). It takes native char string as parameter Parameters: schemaLocation  the list of schemas to use See also: setExternalSchemaLocation(const XMLCh* const)

void IDOMParser::setExternalSchemaLocation (  const XMLCh *const    schemaLocation )

This method allows the user to specify a list of schemas to use. If the targetNamespace of a schema specified using this method matches the targetNamespace of a schema occuring in the instance document in the schemaLocation attribute, or if the targetNamespace matches the namespace attribute of the "import" element, the schema specified by the user using this method will be used (i.e., the schemaLocation attribute in the instance document or on the "import" element will be effectively ignored). If this method is called more than once, only the last one takes effect. The syntax is the same as for schemaLocation attributes in instance documents: e.g, "http://www.example.com file_name.xsd". The user can specify more than one XML Schema in the list. Parameters: schemaLocation  the list of schemas to use See also: getExternalSchemaLocation

void IDOMParser::setIncludeIgnorableWhitespace (  const bool    include )  [inline]

Set the 'include ignorable whitespace' flag This method allows the user to specify whether a validating parser should include ignorable whitespaces as text nodes. It has no effect on non-validating parsers which always include non-markup text. 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 nodes only. When set to false, all ignorable whitespace will be discarded and no text node is added to the DOM tree. Note: applications intended to process the "xml:space" attribute should not set this flag to false. And this flag also overrides any schema datateye whitespace facets, that is, all ignorable whitespace will be discarded even though 'preserve' is set in schema datatype whitespace facets. Parameters: include  The new state of the include ignorable whitespace flag. See also: getIncludeIgnorableWhitespace

void IDOMParser::setURLEntityCacheDir (  const char *    cachedir )

This method is same as setURLEntityCacheDir(const XMLCh* const). It takes native char string as parameter Parameters: cachedir  The absolute path of the directory where the files are to be cached. See also: getURLEntityCacheDir

void IDOMParser::setURLEntityCacheDir (  const XMLCh *    cachedir )

Set the absolute path where the files are to be cached. This method allows the users to specify the absolute path of the directory where the files are to be cached. If this method is not invoked by the user but the Caching is turned on, the current directory is used by default. The parser's default value is : PWD Parameters: cachedir  The absolute path of the directory where the files are to be cached. See also: getURLEntityCacheDir

void IDOMParser::setURLEntityCaching (  const bool    useCache )

Set the external entity file caching flag This method allows users to enable or disable the parsers external entity file caching. When set to false, the external entity files are not cached locally. The parser's default behaviour is: true. (always caches files) Parameters: useCache  The value specifying if file caching should be turned on or off. See also: getURLEntityCaching

void IDOMParser::setValidationConstraintFatal (  const bool    newState )

This method allows users to set the parser's behaviour when it encounters a validtion constraint error. If set to true, and the the parser is set to exit when it encounter the first fatal error, the parser will exit at the first encounter. If false, then it will report the error and continue processing. The default value is 'false'. Parameters: newState  The value specifying whether the parser should continue or exit when it encounters a validation constraint error. See also: getValidationConstraintFatal

void IDOMParser::setValidationSchemaFullChecking (  const bool    schemaFullChecking )

This method allows the user to turn full Schema constraint checking on/off. Only takes effect if Schema validation is enabled. If turned off, partial constraint checking is done. Full schema constraint checking includes those checking that may be time-consuming or memory intensive. Currently, particle unique attribution constraint checking and particle derivation resriction checking are controlled by this option. The parser's default state is: false. Parameters: schemaFullChecking  True to turn on full schema constraint checking. See also: getValidationSchemaFullChecking

void IDOMParser::setValidationScheme (  const ValSchemes    newScheme )

This method allows users to set the validation scheme to be used by this parser. The value is one of the ValSchemes enumerated values defined by this class: Val_Never - turn off validation Val_Always - turn on validation Val_Auto - turn on validation if any internal/external DTD subset have been seen The parser's default state is: Val_Auto. Parameters: newScheme  The new validation scheme to use. See also: getValidationScheme

void IDOMParser::startDocument (    )  [virtual]

Handle a start document event This method is used to report the start of the parsing process. Implements XMLDocumentHandler.

void IDOMParser::startElement (  const XMLElementDecl &    elemDecl, const unsigned int    urlId, const XMLCh *const    elemPrefix, const RefVectorOf< XMLAttr > &    attrList, const unsigned int    attrCount, const bool    isEmpty, const bool    isRoot )  [virtual]

Handle a start element event 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 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.) Parameters: elemDecl  A const reference to the object containing element declaration information. urlId  An id referring to the namespace prefix, if namespaces setting is switched on. elemPrefix  A const pointer to a Unicode string containing the namespace prefix for this element. Applicable only when namespace processing is enabled. attrList  A const reference to the object containing the list of attributes just scanned for this element. attrCount  A count of number of attributes in the list specified by the parameter 'attrList'. isEmpty  A flag indicating whether this is an empty element or not. If empty, then no endElement() call will be made. isRoot  A flag indicating whether this element was the root element. See also: DocumentHandler#startElement Implements XMLDocumentHandler.

void IDOMParser::startEntityReference (  const XMLEntityDecl &    entDecl )  [virtual]

Handle a start entity reference event 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. Parameters: entDecl  A const reference to the object containing the entity declaration information. Implements XMLDocumentHandler.

void IDOMParser::startInputSource (  const InputSource &    inputSource )  [inline, virtual]

Handle a 'start input source' event This method is used to indicate the start of parsing an external entity file. This method is a no-op for this IDOM parse implementation. Parameters: inputSource  A const reference to the InputSource object which points to the external entity being parsed. Implements XMLEntityHandler.

void IDOMParser::XMLDecl (  const XMLCh *const    versionStr, const XMLCh *const    encodingStr, const XMLCh *const    standaloneStr, const XMLCh *const    actualEncStr )  [virtual]

Handle an XMLDecl event This method is used to report the XML decl scanned by the parser. Refer to the XML specification to see the meaning of parameters. This method is a no-op for this IDOM implementation. Parameters: versionStr  A const pointer to a Unicode string representing version string value. encodingStr  A const pointer to a Unicode string representing the encoding string value. standaloneStr  A const pointer to a Unicode string representing the standalone string value. actualEncStr  A const pointer to a Unicode string representing the actual encoding string value. Implements XMLDocumentHandler.

---

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

• IDOMParser.hpp
• IDOMParser.cpp

---