|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Object org.attoparser.AbstractAttoHandler org.attoparser.markup.AbstractBasicMarkupAttoHandler org.attoparser.markup.AbstractDetailedMarkupAttoHandler
public abstract class AbstractDetailedMarkupAttoHandler
Base abstract implementations for markup-specialized attohandlers that not only differentiate
among the different types of markup structures (as its superclass AbstractBasicMarkupAttoHandler
does), but also divide both elements (tags) and DOCTYPE clauses into its components, lauching
different events for them.
Handlers extending from this class can make use of a DocumentRestrictions
instance
specifying a set of restrictions to be applied during document parsing (for example,
for ensuring that a document is well-formed from an XML/XHTML standpoint).
As for 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 |
AbstractDetailedMarkupAttoHandler()
|
protected |
AbstractDetailedMarkupAttoHandler(DocumentRestrictions documentRestrictions)
|
Method Summary | |
---|---|
void |
handleAttribute(char[] buffer,
int nameOffset,
int nameLen,
int nameLine,
int nameCol,
int operatorOffset,
int operatorLen,
int operatorLine,
int operatorCol,
int valueContentOffset,
int valueContentLen,
int valueOuterOffset,
int valueOuterLen,
int valueLine,
int valueCol)
Called when an attribute is found. |
void |
handleAttributeSeparator(char[] buffer,
int offset,
int len,
int line,
int col)
Called when a separation between attributes 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 |
handleCloseElementEnd(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the end of a close element (a close tag) is found. |
void |
handleCloseElementName(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the name of a close element (a close tag) is found. |
void |
handleCloseElementStart(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the start of a close element (a close tag) 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 |
handleDocType(char[] buffer,
int keywordOffset,
int keywordLen,
int keywordLine,
int keywordCol,
int elementNameOffset,
int elementNameLen,
int elementNameLine,
int elementNameCol,
int typeOffset,
int typeLen,
int typeLine,
int typeCol,
int publicIdOffset,
int publicIdLen,
int publicIdLine,
int publicIdCol,
int systemIdOffset,
int systemIdLen,
int systemIdLine,
int systemIdCol,
int internalSubsetOffset,
int internalSubsetLen,
int internalSubsetLine,
int internalSubsetCol,
int outerOffset,
int outerLen,
int outerLine,
int outerCol)
Called when a DOCTYPE clause is found. |
void |
handleDocumentEnd(long endTimeNanos,
long totalTimeNanos)
Called at the end of document parsing, adding timing information. |
void |
handleDocumentEnd(long endTimeNanos,
long totalTimeNanos,
DocumentRestrictions documentRestrictions)
Called when document parsing ends. |
void |
handleDocumentStart(long startTimeNanos)
Called at the beginning of document parsing, adding timing information. |
void |
handleDocumentStart(long startTimeNanos,
DocumentRestrictions documentRestrictions)
Called when document parsing starts. |
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 |
handleOpenElementEnd(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the end of an open element (an open tag) is found. |
void |
handleOpenElementName(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the name of an open element (an open tag) is found. |
void |
handleOpenElementStart(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the start of an open element (an open tag) 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 |
handleStandaloneElementEnd(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the end of a standalone element (a minimized tag) is found. |
void |
handleStandaloneElementName(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the name of a standalone element (a minimized tag) is found. |
void |
handleStandaloneElementStart(char[] buffer,
int offset,
int len,
int line,
int col)
Called when the start of a standalone element (a minimized tag) 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. |
void |
handleXmlDeclarationDetail(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 when using a handler extending from AbstractDetailedMarkupAttoHandler . |
Methods inherited from class org.attoparser.markup.AbstractBasicMarkupAttoHandler |
---|
handleCDATASection, handleComment, handleProcessingInstruction, handleStructure |
Methods inherited from class org.attoparser.AbstractAttoHandler |
---|
getEndTimeNanos, getStartTimeNanos, getTotalTimeNanos, handleDocumentEnd, handleDocumentStart, handleText |
Methods inherited from class Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
protected AbstractDetailedMarkupAttoHandler()
protected AbstractDetailedMarkupAttoHandler(DocumentRestrictions documentRestrictions)
Method Detail |
---|
public final void handleDocumentStart(long startTimeNanos) throws AttoParseException
ITimedDocumentHandling
Called at the beginning of document parsing, adding timing information.
handleDocumentStart
in interface ITimedDocumentHandling
handleDocumentStart
in class AbstractAttoHandler
startTimeNanos
- the current time (in nanoseconds) obtained when parsing starts.
AttoParseException
public final void handleDocumentEnd(long endTimeNanos, long totalTimeNanos) throws AttoParseException
ITimedDocumentHandling
Called at the end of document parsing, adding timing information.
handleDocumentEnd
in interface ITimedDocumentHandling
handleDocumentEnd
in class AbstractAttoHandler
endTimeNanos
- the current time (in nanoseconds) obtained when parsing ends.totalTimeNanos
- the difference between current times at the start and end of
parsing (in nanoseconds)
AttoParseException
public final 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
handleXmlDeclaration
in class AbstractBasicMarkupAttoHandler
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 final 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
handleDocType
in class AbstractBasicMarkupAttoHandler
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 final 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
handleStandaloneElement
in class AbstractBasicMarkupAttoHandler
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 final 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
handleOpenElement
in class AbstractBasicMarkupAttoHandler
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 final 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
handleCloseElement
in class AbstractBasicMarkupAttoHandler
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 handleDocumentStart(long startTimeNanos, DocumentRestrictions documentRestrictions) throws AttoParseException
Called when document parsing starts.
startTimeNanos
- the starting time, in nanoseconds.documentRestrictions
- the document restrictions being applied.
AttoParseException
public void handleDocumentEnd(long endTimeNanos, long totalTimeNanos, DocumentRestrictions documentRestrictions) throws AttoParseException
Called when document parsing ends.
endTimeNanos
- the parsing end time, in nanoseconds.totalTimeNanos
- the difference between parsing start and end times.documentRestrictions
- the document restrictions being applied.
AttoParseException
public void handleXmlDeclarationDetail(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
Called when a XML Declaration is found when using a handler extending from
AbstractDetailedMarkupAttoHandler
.
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.
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 handleStandaloneElementStart(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the start of a standalone element (a minimized tag) is found. This "start" is considered to be the "<" symbol the element starts with.
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.
handleStandaloneElementStart
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleStandaloneElementName(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the name of a standalone element (a minimized tag) is found. E.g., the "element name" of an element like <img src="images/logo.png" /> would be "img".
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.
handleStandaloneElementName
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleStandaloneElementEnd(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the end of a standalone element (a minimized tag) is found. This "end" is considered to be the ">" symbol the element ends with.
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.
handleStandaloneElementEnd
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleOpenElementStart(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the start of an open element (an open tag) is found. This "start" is considered to be the "<" symbol the element starts with.
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.
handleOpenElementStart
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleOpenElementName(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the name of an open element (an open tag) is found. E.g., the "element name" of an element like <div class="basic"> would be "div".
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.
handleOpenElementName
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleOpenElementEnd(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the end of an open element (an open tag) is found. This "end" is considered to be the ">" symbol the element ends with.
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.
handleOpenElementEnd
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleCloseElementStart(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the start of a close element (a close tag) is found. This "start" is considered to be the "<" symbol the element starts with.
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.
handleCloseElementStart
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleCloseElementName(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the name of a close element (a close tag) is found. E.g., the "element name" of an element like </div> would be "div".
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.
handleCloseElementName
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleCloseElementEnd(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IDetailedElementHandling
Called when the end of a close element (a close tag) is found. This "end" is considered to be the ">" symbol the element ends with.
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.
handleCloseElementEnd
in interface IDetailedElementHandling
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the artifact starts.len
- the length (in chars) of the artifact, starting in offset.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 handleAttribute(char[] buffer, int nameOffset, int nameLen, int nameLine, int nameCol, int operatorOffset, int operatorLen, int operatorLine, int operatorCol, int valueContentOffset, int valueContentLen, int valueOuterOffset, int valueOuterLen, int valueLine, int valueCol) throws AttoParseException
IAttributeSequenceHandling
Called when an attribute is found.
Three [offset, len] pairs are provided for three partitions (name, operator, valueContent and valueOuter):
class="basic_column"
[NAM]* [VALUECONTE]| (*) = [OPERATOR]
| [VALUEOUTER--]
[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.
handleAttribute
in interface IAttributeSequenceHandling
buffer
- the document buffer (not copied)nameOffset
- offset for the name partition.nameLen
- length of the name partition.nameLine
- the line in the original document where the name partition starts.nameCol
- the column in the original document where the name partition starts.operatorOffset
- offset for the operator partition.operatorLen
- length of the operator partition.operatorLine
- the line in the original document where the operator partition starts.operatorCol
- the column in the original document where the operator partition starts.valueContentOffset
- offset for the valueContent partition.valueContentLen
- length of the valueContent partition.valueOuterOffset
- offset for the valueOuter partition.valueOuterLen
- length of the valueOuter partition.valueLine
- the line in the original document where the value (outer) partition starts.valueCol
- the column in the original document where the value (outer) partition starts.
AttoParseException
public void handleAttributeSeparator(char[] buffer, int offset, int len, int line, int col) throws AttoParseException
IAttributeSequenceHandling
Called when a separation between attributes is found.
This attribute separators can contain any amount of whitespace, including line feeds:
<div id="main" class="basic_column">
[ATTSEP]
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.
handleAttributeSeparator
in interface IAttributeSequenceHandling
buffer
- the document buffer (not copied)offset
- offset for the artifact.len
- length of the artifact.line
- the line in the original document where the artifact starts.col
- the column in the original document where the artifact starts.
AttoParseException
public void handleDocType(char[] buffer, int keywordOffset, int keywordLen, int keywordLine, int keywordCol, int elementNameOffset, int elementNameLen, int elementNameLine, int elementNameCol, int typeOffset, int typeLen, int typeLine, int typeCol, int publicIdOffset, int publicIdLen, int publicIdLine, int publicIdCol, int systemIdOffset, int systemIdLen, int systemIdLine, int systemIdCol, int internalSubsetOffset, int internalSubsetLen, int internalSubsetLine, int internalSubsetCol, int outerOffset, int outerLen, int outerLine, int outerCol) throws AttoParseException
IDetailedDocTypeHandling
Called when a DOCTYPE clause is found.
This method reports the DOCTYPE clause splitting it into its different parts.
Seven [offset, len] pairs are provided for seven partitions (outer, keyword, elementName, type, publicId, systemId and internalSubset) of the DOCTYPE clause:
<!DOCTYPE html PUBLIC ".........." ".........." [................]>
| [KEYWO] [EN] [TYPE] [PUBLICID] [SYSTEMID] [INTERNALSUBSET] |
[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 IDetailedDocTypeHandling
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.elementNameOffset
- offset for the elementName partition.elementNameLen
- length of the elementName partition.elementNameLine
- the line in the original document where the elementName partition starts.elementNameCol
- the column in the original document where the elementName partition starts.typeOffset
- offset for the type partition.typeLen
- length of the type partition.typeLine
- the line in the original document where the type partition starts.typeCol
- the column in the original document where the type partition starts.publicIdOffset
- offset for the publicId partition.publicIdLen
- length of the publicId partition.publicIdLine
- the line in the original document where the publicId partition starts.publicIdCol
- the column in the original document where the publicId partition starts.systemIdOffset
- offset for the systemId partition.systemIdLen
- length of the systemId partition.systemIdLine
- the line in the original document where the systemId partition starts.systemIdCol
- the column in the original document where the systemId partition starts.internalSubsetOffset
- offset for the internalSubsetId partition.internalSubsetLen
- length of the internalSubsetId partition.internalSubsetLine
- the line in the original document where the internalSubsetId partition starts.internalSubsetCol
- the column in the original document where the internalSubsetId partition starts.outerOffset
- offset for the outer partition.outerLen
- length of the outer partition.outerLine
- the line in the original document where this artifact starts.outerCol
- 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 |