|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Object org.attoparser.AbstractAttoHandler org.attoparser.markup.AbstractBasicMarkupAttoHandler
public abstract class AbstractBasicMarkupAttoHandler
Base abstract implementations for markup-specialized attohandlers that need differentiation among the different types of markup structures.
This implementation differentiates among:
This class provides empty implementations for all event handlers, so that subclasses can override only the methods they need.
Constructor Summary | |
---|---|
protected |
AbstractBasicMarkupAttoHandler()
|
Method Summary | |
---|---|
void |
handleCDATASection(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when a CDATA section is found. |
void |
handleCloseElement(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when a close element (a close tag) is found. |
void |
handleComment(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when a comment is found. |
void |
handleDocType(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when a DOCTYPE clause is found. |
void |
handleOpenElement(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when an open element (an open tag) is found. |
void |
handleProcessingInstruction(char[] buffer,
int targetOffset,
int targetLen,
int targetLine,
int targetCol,
int contentOffset,
int contentLen,
int contentLine,
int contentCol,
int outerOffset,
int outerLen,
int line,
int col)
Called when a Processing Instruction is found. |
void |
handleStandaloneElement(char[] buffer,
int contentOffset,
int contentLen,
int outerOffset,
int outerLen,
int line,
int col)
Called when a standalone element (a minimized tag) is found. |
void |
handleStructure(char[] buffer,
int offset,
int len,
int line,
int col)
Called when a structure artifact is found. |
void |
handleXmlDeclaration(char[] buffer,
int keywordOffset,
int keywordLen,
int keywordLine,
int keywordCol,
int versionOffset,
int versionLen,
int versionLine,
int versionCol,
int encodingOffset,
int encodingLen,
int encodingLine,
int encodingCol,
int standaloneOffset,
int standaloneLen,
int standaloneLine,
int standaloneCol,
int outerOffset,
int outerLen,
int line,
int col)
Called when a XML Declaration is found. |
Methods inherited from class org.attoparser.AbstractAttoHandler |
---|
getEndTimeNanos, getStartTimeNanos, getTotalTimeNanos, handleDocumentEnd, handleDocumentEnd, handleDocumentStart, handleDocumentStart, handleText |
Methods inherited from class Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
protected AbstractBasicMarkupAttoHandler()
Method Detail |
---|
public final void handleStructure(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IAttoHandler
Called when a structure artifact is found.
Depending on the specific IAttoParser
implementation being used,
"structure" might have a different meaning. In markup-oriented parsers (like the default
MarkupAttoParser
) implementation provided, structures
like tags (a.k.a. elements), DOCTYPEs, XML Declarations, processing instructions,
etc. are reported using this event handler.
Lower-level IAttoHandler
implementations will usually provide a finer-grained
differentiation among the different types of structures (see for example
AbstractBasicMarkupAttoHandler
or
AbstractDetailedMarkupAttoHandler
).
Structure artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleStructure
in interface IAttoHandler
handleStructure
in class AbstractAttoHandler
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the structure artifact starts.len
- the length (in chars) of the structure artifact, starting in offset.line
- the line in the original document where this structure artifact starts.col
- the column in the original document where this structure artifact starts.
AttoParseException
public void handleDocType(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IBasicDocTypeHandling
Called when a DOCTYPE clause is found.
This method reports the DOCTYPE clause as a whole, not splitting it into its different
parts (root element name, publicId, etc.). This splitting should normally be done by implementations
of the IDetailedDocTypeHandling
interface (like AbstractDetailedMarkupAttoHandler
).
Two [offset, len] pairs are provided for two partitions (outer and content) of the DOCTYPE clause:
<!DOCTYPE html PUBLIC "..." "...">
| [CONTENT----------------------]|
[OUTER---------------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleDocType
in interface IBasicDocTypeHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleStandaloneElement(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IBasicElementHandling
Called when a standalone element (a minimized tag) is found.
This method reports the element as a whole, not splitting it among its different
parts (element name, attributes). This splitting should normally be done by implementations
of the IDetailedElementHandling
interface (like AbstractDetailedMarkupAttoHandler
).
Two [offset, len] pairs are provided for two partitions (outer and content) of the element:
<img src="/images/logo.png"/>
|[CONTENT-----------------] |
[OUTER----------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleStandaloneElement
in interface IBasicElementHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleOpenElement(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IBasicElementHandling
Called when an open element (an open tag) is found.
This method reports the element as a whole, not splitting it among its different
parts (element name, attributes). This splitting should normally be done by implementations
of the IDetailedElementHandling
interface (like AbstractDetailedMarkupAttoHandler
).
Two [offset, len] pairs are provided for two partitions (outer and content) of the element:
<div class="main_section">
|[CONTENT---------------]|
[OUTER-------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleOpenElement
in interface IBasicElementHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleCloseElement(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IBasicElementHandling
Called when a close element (a close tag) is found.
This method reports the element as a whole, not splitting it among its different
parts (element name). This splitting should normally be done by implementations
of the IDetailedElementHandling
interface (like AbstractDetailedMarkupAttoHandler
).
Two [offset, len] pairs are provided for two partitions (outer and content) of the element:
</div>
| [C]|
[OUTE]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleCloseElement
in interface IBasicElementHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleComment(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
ICommentHandling
Called when a comment is found.
Two [offset, len] pairs are provided for two partitions (outer and content):
<!-- this is a comment -->
| [CONTENT----------] |
[OUTER-------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleComment
in interface ICommentHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleCDATASection(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws AttoParseException
ICDATASectionHandling
Called when a CDATA section is found.
Two [offset, len] pairs are provided for two partitions (outer and content):
<![CDATA[ this is a CDATA section ]]>
| [CONTENT----------------] |
[OUTER------------------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleCDATASection
in interface ICDATASectionHandling
buffer
- the document buffer (not copied)contentOffset
- offset for the content partition.contentLen
- length of the content partition.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleXmlDeclaration(char[] buffer, int keywordOffset, int keywordLen, int keywordLine, int keywordCol, int versionOffset, int versionLen, int versionLine, int versionCol, int encodingOffset, int encodingLen, int encodingLine, int encodingCol, int standaloneOffset, int standaloneLen, int standaloneLine, int standaloneCol, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IXmlDeclarationHandling
Called when a XML Declaration is found.
Five [offset, len] pairs are provided for five partitions (outer, keyword, version, encoding and standalone):
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
| [K] [V] [ENC] [S] |
[OUTER------------------------------------------------]
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleXmlDeclaration
in interface IXmlDeclarationHandling
buffer
- the document buffer (not copied)keywordOffset
- offset for the keyword partition.keywordLen
- length of the keyword partition.keywordLine
- the line in the original document where the keyword partition starts.keywordCol
- the column in the original document where the keyword partition starts.versionOffset
- offset for the version partition.versionLen
- length of the version partition.versionLine
- the line in the original document where the version partition starts.versionCol
- the column in the original document where the version partition starts.encodingOffset
- offset for the encoding partition.encodingLen
- length of the encoding partition.encodingLine
- the line in the original document where the encoding partition starts.encodingCol
- the column in the original document where the encoding partition starts.standaloneOffset
- offset for the standalone partition.standaloneLen
- length of the standalone partition.standaloneLine
- the line in the original document where the standalone partition starts.standaloneCol
- the column in the original document where the standalone partition starts.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
public void handleProcessingInstruction(char[] buffer, int targetOffset, int targetLen, int targetLine, int targetCol, int contentOffset, int contentLen, int contentLine, int contentCol, int outerOffset, int outerLen, int line, int col) throws AttoParseException
IProcessingInstructionHandling
Called when a Processing Instruction is found.
Three [offset, len] pairs are provided for three partitions (outer, target and content):
<?xls-stylesheet somePar1="a" somePar2="b"?>
| [TARGET------] [CONTENT----------------] |
[OUTER-------------------------------------]
Note that, although XML Declarations have the same format as processing instructions,
they are not considered as such and therefore are handled by a different interface
(IXmlDeclarationHandling
).
Artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported structures should be copied if they need to be stored (either by copying len chars from the buffer char[] starting in offset or by creating a String from it using the same specification).
Implementations of this handler should never modify the document buffer.
handleProcessingInstruction
in interface IProcessingInstructionHandling
buffer
- the document buffer (not copied)targetOffset
- offset for the target partition.targetLen
- length of the target partition.targetLine
- the line in the original document where the target partition starts.targetCol
- the column in the original document where the target partition starts.contentOffset
- offset for the content partition.contentLen
- length of the content partition.contentLine
- the line in the original document where the content partition starts.contentCol
- the column in the original document where the content partition starts.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.
AttoParseException
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |