Class BlockSelectorMarkupHandler
- java.lang.Object
-
- org.attoparser.AbstractMarkupHandler
-
- org.attoparser.select.BlockSelectorMarkupHandler
-
- All Implemented Interfaces:
IAttributeSequenceHandler
,ICDATASectionHandler
,ICommentHandler
,IDocTypeHandler
,IDocumentHandler
,IElementHandler
,IMarkupHandler
,IProcessingInstructionHandler
,ITextHandler
,IXMLDeclarationHandler
public final class BlockSelectorMarkupHandler extends AbstractMarkupHandler
Implementation of
IMarkupHandler
able to apply block selection based on a set of specified markup selectors (seeorg.attoparser.select
).Block selection means that once an element is selected by any of the specified selectors, the entire subtree of that element is also considered selected.
This markup handler will apply the specified markup selectors and divide parsing events between two (possibly different) chained markup handlers implementing
IMarkupHandler
: the selectedHandler and the nonSelectedHandler. Also, document start/end events will be sent to the selectedHandler unless specified otherwise by means of thesetDocumentStartEndHandler(org.attoparser.IMarkupHandler)
method.Additionally, this handler will update the
ParseSelection
object currently in use by the handler chain (which has been set to handlers by means of theIMarkupHandler.setParseSelection(ParseSelection)
method). For every event fired on the delegated handlers, the parse selection object will contain up-to-date information about the selectors (at every active selection level) that are currently matching the delegated events.Also note that this filtering will be done in the most memory-efficient way, without the need to create any large extra String or char[] objects apart from a minimal element buffer object which will be reused throughout all the parsing process. This makes the execution of this handler extremely fast and integrated with the parsing process itself.
In order to see how this handler works we can see some examples. For instance, given the following markup:
<!DOCTYPE html> <html> <body> <h1>AttoParser</h1> <div class="content"> AttoParser is able to select <strong>just a fragment of markup</strong>. </div> </body> </html>
...and a
BlockSelectorMarkupHandler
initialized with:- An
OutputMarkupHandler
object as selectedHandler. - A
DiscardMarkupHandler
object as nonSelectedHandler. This is the default non-selected handler used when none is specified.
Using selector "div.content", we would get:
<div class="content"> AttoParser is able to select <strong>just a fragment of markup</strong>. </div>
If we had two selectors, "h1" and "div//text()", we would get:
<h1>AttoParser</h1> AttoParser is able to select just a fragment of markup.
Have a look at the package info for
org.attoparser.select
for a complete explanation on markup selector syntax.Note that, as with most handlers, this class is not thread-safe. Also, instances of this class should not be reused across parsing operations.
- Since:
- 2.0.0
-
-
Field Summary
Fields Modifier and Type Field Description private static DiscardMarkupHandler
DISCARD_MARKUP_HANDLER
private IMarkupHandler
documentStartEndHandler
private SelectorElementBuffer
elementBuffer
private boolean
insideAllSelectorMatchingBlock
private static int
MARKUP_BLOCKS_LEN
private int
markupBlockIndex
private int[]
markupBlocks
private int
markupLevel
private int[]
matchingMarkupLevelsPerSelector
private IMarkupHandler
nonSelectedHandler
private IMarkupSelectorReferenceResolver
referenceResolver
private IMarkupHandler
selectedHandler
private ParseSelection
selection
private int
selectionIndex
private MarkupSelectorFilter[]
selectorFilters
private boolean[]
selectorMatches
private java.lang.String[]
selectors
private int
selectorsLen
private boolean
someSelectorsMatch
-
Constructor Summary
Constructors Constructor Description BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String selector)
Create a new instance of this handler, specifying the selected handler and the selector to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String[] selectors)
Create a new instance of this handler, specifying the selected handler and the selectors to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String[] selectors, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying the selected handler, as well as a markup selector reference resolver and the selectors to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String selector, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying the selected handler, as well as a markup selector reference resolver and the selector to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String selector)
Create a new instance of this handler, specifying both the selected and non-selected handlers, and the selector to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String[] selectors)
Create a new instance of this handler, specifying both the selected and non-selected handlers, and the selectors to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String[] selectors, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying both the selected and non-selected handlers, as well as a markup selector reference resolver and the selectors to be used.BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String selector, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying both the selected and non-selected handlers, as well as a markup selector reference resolver and the selector to be used.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description private void
checkSizeOfMarkupBlocksStructure(int markupLevel)
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
handleAutoCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called for signaling the end of an auto-close element, created for balancing an unclosed tag.void
handleAutoCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called for signaling the start of an auto-close element (a synthetic close tag), created for balancing an unclosed tag.void
handleAutoOpenElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called for signaling the end of an auto-open element (a synthetic open tag), created for adapting parsed markup to a specification such as, for example, HTML5.void
handleAutoOpenElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called for signaling the start of an auto-open element (a synthetic open tag), created for adapting parsed markup to a specification such as, for example, HTML5.void
handleCDATASection(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col)
Called when a CDATA section is found.void
handleCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called when the end of a close element (a close tag) is found.void
handleCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called when the start of 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 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, int line, int col)
Called at the end of document parsing.void
handleDocumentStart(long startTimeNanos, int line, int col)
Called at the beginning of document parsing.void
handleInnerWhiteSpace(char[] buffer, int offset, int len, int line, int col)
Called when an amount of white space is found inside an element.void
handleOpenElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called when the end of an open element (an open tag) is found.void
handleOpenElementStart(char[] buffer, int nameOffset, int nameLen, 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
handleStandaloneElementEnd(char[] buffer, int nameOffset, int nameLen, boolean minimized, int line, int col)
Called when the end of a standalone element (an element with no closing tag) is foundvoid
handleStandaloneElementStart(char[] buffer, int nameOffset, int nameLen, boolean minimized, int line, int col)
Called when a standalone element (an element with no closing tag) is found.void
handleText(char[] buffer, int offset, int len, int line, int col)
Called when a text artifact is found.void
handleUnmatchedCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called when the end of an unmatched close element (close tag) is found.void
handleUnmatchedCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col)
Called when the start of an unmatched close element (close 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.private void
markCurrentSelection()
void
setDocumentStartEndHandler(IMarkupHandler documentStartEndHandler)
Sets theIMarkupHandler
instance to which the document start and document end events should be delegated.void
setParseConfiguration(ParseConfiguration parseConfiguration)
Sets theParseConfiguration
object that will be used during the parsing operation.void
setParseSelection(ParseSelection selection)
Sets theParseSelection
object that represents the different levels of selectors (if any) that are currently active for the fired events.void
setParseStatus(ParseStatus status)
Sets theParseStatus
object that will be used during the parsing operation.private void
unmarkCurrentSelection()
private void
updateInsideAllSelectorMatchingBlockFlag()
-
-
-
Field Detail
-
DISCARD_MARKUP_HANDLER
private static final DiscardMarkupHandler DISCARD_MARKUP_HANDLER
-
selectedHandler
private final IMarkupHandler selectedHandler
-
nonSelectedHandler
private final IMarkupHandler nonSelectedHandler
-
selection
private ParseSelection selection
-
selectionIndex
private int selectionIndex
-
referenceResolver
private final IMarkupSelectorReferenceResolver referenceResolver
-
elementBuffer
private final SelectorElementBuffer elementBuffer
-
documentStartEndHandler
private IMarkupHandler documentStartEndHandler
-
selectorsLen
private final int selectorsLen
-
selectors
private final java.lang.String[] selectors
-
selectorMatches
private final boolean[] selectorMatches
-
selectorFilters
private final MarkupSelectorFilter[] selectorFilters
-
insideAllSelectorMatchingBlock
private boolean insideAllSelectorMatchingBlock
-
someSelectorsMatch
private boolean someSelectorsMatch
-
markupLevel
private int markupLevel
-
matchingMarkupLevelsPerSelector
private int[] matchingMarkupLevelsPerSelector
-
MARKUP_BLOCKS_LEN
private static final int MARKUP_BLOCKS_LEN
- See Also:
- Constant Field Values
-
markupBlocks
private int[] markupBlocks
-
markupBlockIndex
private int markupBlockIndex
-
-
Constructor Detail
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String selector)
Create a new instance of this handler, specifying the selected handler and the selector to be used.
Given no non-selected handler is specified, an instance of
DiscardMarkupHandler
is used. So all non-selected events will be just discarded.- Parameters:
selectedHandler
- the handler to which selected events will be delegated.selector
- the selector to be used. Cannot be null.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String selector, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying the selected handler, as well as a markup selector reference resolver and the selector to be used.
Given no non-selected handler is specified, an instance of
DiscardMarkupHandler
is used. So all non-selected events will be just discarded.- Parameters:
selectedHandler
- the handler to which selected events will be delegated.selector
- the selector to be used. Cannot be null.referenceResolver
- the reference resolver to be used. Can be null if none is required.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String selector)
Create a new instance of this handler, specifying both the selected and non-selected handlers, and the selector to be used.
- Parameters:
selectedHandler
- the handler to which selected events will be delegated.nonSelectedHandler
- the handler to which non-selected events will be delegated.selector
- the selector to be used. Cannot be null.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String selector, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying both the selected and non-selected handlers, as well as a markup selector reference resolver and the selector to be used.
- Parameters:
selectedHandler
- the handler to which selected events will be delegated.nonSelectedHandler
- the handler to which non-selected events will be delegated.selector
- the selector to be used. Cannot be null.referenceResolver
- the reference resolver to be used. Can be null if none is required.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String[] selectors)
Create a new instance of this handler, specifying the selected handler and the selectors to be used.
Given no non-selected handler is specified, an instance of
DiscardMarkupHandler
is used. So all non-selected events will be just discarded.- Parameters:
selectedHandler
- the handler to which selected events will be delegated.selectors
- the selectors to be used. Cannot be neither null nor empty.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, java.lang.String[] selectors, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying the selected handler, as well as a markup selector reference resolver and the selectors to be used.
Given no non-selected handler is specified, an instance of
DiscardMarkupHandler
is used. So all non-selected events will be just discarded.- Parameters:
selectedHandler
- the handler to which selected events will be delegated.selectors
- the selectors to be used. Cannot be neither null nor empty.referenceResolver
- the reference resolver to be used. Can be null if none is required.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String[] selectors)
Create a new instance of this handler, specifying both the selected and non-selected handlers, and the selectors to be used.
- Parameters:
selectedHandler
- the handler to which selected events will be delegated.nonSelectedHandler
- the handler to which non-selected events will be delegated.selectors
- the selectors to be used. Cannot be neither null nor empty.
-
BlockSelectorMarkupHandler
public BlockSelectorMarkupHandler(IMarkupHandler selectedHandler, IMarkupHandler nonSelectedHandler, java.lang.String[] selectors, IMarkupSelectorReferenceResolver referenceResolver)
Create a new instance of this handler, specifying both the selected and non-selected handlers, as well as a markup selector reference resolver and the selectors to be used.
- Parameters:
selectedHandler
- the handler to which selected events will be delegated.nonSelectedHandler
- the handler to which non-selected events will be delegated.selectors
- the selectors to be used. Cannot be neither null nor empty.referenceResolver
- the reference resolver to be used. Can be null if none is required.
-
-
Method Detail
-
setDocumentStartEndHandler
public void setDocumentStartEndHandler(IMarkupHandler documentStartEndHandler)
Sets the
IMarkupHandler
instance to which the document start and document end events should be delegated.This is specified separately in order to avoid undesired event duplicities. By default, the selected handler specified during construction will be the one receiving these events.
If sending these events to both selected and non-selected handlers is required, developers can make use of
DuplicateMarkupHandler
.- Parameters:
documentStartEndHandler
- the handler these events will be delegated to.
-
setParseConfiguration
public void setParseConfiguration(ParseConfiguration parseConfiguration)
Description copied from interface:IMarkupHandler
Sets the
ParseConfiguration
object that will be used during the parsing operation. This object will normally have been specified to the parser object during its instantiation or initialization.This method is always called by the parser before calling any other event handling method.
Note that this method can be safely ignored by most implementations, as there are very few scenarios in which this kind of interaction would be consisdered relevant.
- Specified by:
setParseConfiguration
in interfaceIMarkupHandler
- Overrides:
setParseConfiguration
in classAbstractMarkupHandler
- Parameters:
parseConfiguration
- the configuration object.
-
setParseStatus
public void setParseStatus(ParseStatus status)
Description copied from interface:IMarkupHandler
Sets the
ParseStatus
object that will be used during the parsing operation. This object can be used for instructing the parser about specific low-level conditions arisen during event handling.This method is always called by the parser before calling any other event handling method.
Note that this method can be safely ignored by most implementations, as there are very few and very specific scenarios in which this kind of interaction with the parser would be needed. It is therefore mainly for internal use.
- Specified by:
setParseStatus
in interfaceIMarkupHandler
- Overrides:
setParseStatus
in classAbstractMarkupHandler
- Parameters:
status
- the status object.
-
setParseSelection
public void setParseSelection(ParseSelection selection)
Description copied from interface:IMarkupHandler
Sets the
ParseSelection
object that represents the different levels of selectors (if any) that are currently active for the fired events.This method is always called by the parser before calling any other event handling method.
Note that this method can be safely ignored by most implementations, as there are very few scenarios in which this kind of interaction would be consisdered relevant.
- Specified by:
setParseSelection
in interfaceIMarkupHandler
- Overrides:
setParseSelection
in classAbstractMarkupHandler
- Parameters:
selection
- the selection object.
-
handleDocumentStart
public void handleDocumentStart(long startTimeNanos, int line, int col) throws ParseException
Description copied from interface:IDocumentHandler
Called at the beginning of document parsing.
- Specified by:
handleDocumentStart
in interfaceIDocumentHandler
- Overrides:
handleDocumentStart
in classAbstractMarkupHandler
- Parameters:
startTimeNanos
- the current time (in nanoseconds) obtained when parsing starts.line
- the line of the document where parsing starts (usually number 1).col
- the column of the document where parsing starts (usually number 1).- Throws:
ParseException
- if any exceptions occur during handling.
-
handleDocumentEnd
public void handleDocumentEnd(long endTimeNanos, long totalTimeNanos, int line, int col) throws ParseException
Description copied from interface:IDocumentHandler
Called at the end of document parsing.
- Specified by:
handleDocumentEnd
in interfaceIDocumentHandler
- Overrides:
handleDocumentEnd
in classAbstractMarkupHandler
- Parameters:
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).line
- the line of the document where parsing ends (usually the last one).col
- the column of the document where the parsing ends (usually the last one).- Throws:
ParseException
- if any exceptions occur during handling.
-
handleXmlDeclaration
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 ParseException
Description copied from interface:IXMLDeclarationHandler
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.
- Specified by:
handleXmlDeclaration
in interfaceIXMLDeclarationHandler
- Overrides:
handleXmlDeclaration
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleDocType
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 ParseException
Description copied from interface:IDocTypeHandler
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.
- Specified by:
handleDocType
in interfaceIDocTypeHandler
- Overrides:
handleDocType
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleCDATASection
public void handleCDATASection(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws ParseException
Description copied from interface:ICDATASectionHandler
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.
- Specified by:
handleCDATASection
in interfaceICDATASectionHandler
- Overrides:
handleCDATASection
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleText
public void handleText(char[] buffer, int offset, int len, int line, int col) throws ParseException
Description copied from interface:ITextHandler
Called when a text artifact is found.
A sequence of chars is considered to be text when no structures of any kind are contained inside it. In markup parsers, for example, this means no tags (a.k.a. elements), DOCTYPE's, processing instructions, etc. are contained in the sequence.
Text sequences might include any number of new line and/or control characters.
Text artifacts are reported using the document buffer directly, and this buffer should not be considered to be immutable, so reported texts 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.
- Specified by:
handleText
in interfaceITextHandler
- Overrides:
handleText
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)offset
- the offset (position in buffer) where the text artifact starts.len
- the length (in chars) of the text artifact, starting in offset.line
- the line in the original document where this text artifact starts.col
- the column in the original document where this text artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleComment
public void handleComment(char[] buffer, int contentOffset, int contentLen, int outerOffset, int outerLen, int line, int col) throws ParseException
Description copied from interface:ICommentHandler
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.
- Specified by:
handleComment
in interfaceICommentHandler
- Overrides:
handleComment
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleAttribute
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 ParseException
Description copied from interface:IAttributeSequenceHandler
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.
- Specified by:
handleAttribute
in interfaceIAttributeSequenceHandler
- Overrides:
handleAttribute
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleStandaloneElementStart
public void handleStandaloneElementStart(char[] buffer, int nameOffset, int nameLen, boolean minimized, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when a standalone element (an element with no closing tag) is found. The name of the element is also reported.
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.
- Specified by:
handleStandaloneElementStart
in interfaceIElementHandler
- Overrides:
handleStandaloneElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.minimized
- whether the element has been found minimized (<element/>)in code or not.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleStandaloneElementEnd
public void handleStandaloneElementEnd(char[] buffer, int nameOffset, int nameLen, boolean minimized, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the end of a standalone element (an element with no closing tag) is found
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.
- Specified by:
handleStandaloneElementEnd
in interfaceIElementHandler
- Overrides:
handleStandaloneElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.minimized
- whether the element has been found minimized (<element/>)in code or not.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleOpenElementStart
public void handleOpenElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when an open element (an open tag) is found. The name of the element is also reported.
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.
- Specified by:
handleOpenElementStart
in interfaceIElementHandler
- Overrides:
handleOpenElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleOpenElementEnd
public void handleOpenElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the end of an open element (an open tag) is found.
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.
- Specified by:
handleOpenElementEnd
in interfaceIElementHandler
- Overrides:
handleOpenElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleAutoOpenElementStart
public void handleAutoOpenElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called for signaling the start of an auto-open element (a synthetic open tag), created for adapting parsed markup to a specification such as, for example, HTML5. The name of the element is also reported.
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.
- Specified by:
handleAutoOpenElementStart
in interfaceIElementHandler
- Overrides:
handleAutoOpenElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleAutoOpenElementEnd
public void handleAutoOpenElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called for signaling the end of an auto-open element (a synthetic open tag), created for adapting parsed markup to a specification such as, for example, HTML5. The name of the element is also reported.
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.
- Specified by:
handleAutoOpenElementEnd
in interfaceIElementHandler
- Overrides:
handleAutoOpenElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleCloseElementStart
public void handleCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the start of a close element (a close tag) is found. The name of the element is also reported.
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.
- Specified by:
handleCloseElementStart
in interfaceIElementHandler
- Overrides:
handleCloseElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleCloseElementEnd
public void handleCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the end of a close element (a close tag) is found.
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.
- Specified by:
handleCloseElementEnd
in interfaceIElementHandler
- Overrides:
handleCloseElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleAutoCloseElementStart
public void handleAutoCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called for signaling the start of an auto-close element (a synthetic close tag), created for balancing an unclosed tag. The name of the element is also reported.
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.
- Specified by:
handleAutoCloseElementStart
in interfaceIElementHandler
- Overrides:
handleAutoCloseElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleAutoCloseElementEnd
public void handleAutoCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called for signaling the end of an auto-close element, created for balancing an unclosed tag.
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.
- Specified by:
handleAutoCloseElementEnd
in interfaceIElementHandler
- Overrides:
handleAutoCloseElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleUnmatchedCloseElementStart
public void handleUnmatchedCloseElementStart(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the start of an unmatched close element (close tag) is found. The name of the element is also reported.
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.
- Specified by:
handleUnmatchedCloseElementStart
in interfaceIElementHandler
- Overrides:
handleUnmatchedCloseElementStart
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where this artifact starts.col
- the column in the original document where this artifact starts.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleUnmatchedCloseElementEnd
public void handleUnmatchedCloseElementEnd(char[] buffer, int nameOffset, int nameLen, int line, int col) throws ParseException
Description copied from interface:IElementHandler
Called when the end of an unmatched close element (close tag) is found.
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.
- Specified by:
handleUnmatchedCloseElementEnd
in interfaceIElementHandler
- Overrides:
handleUnmatchedCloseElementEnd
in classAbstractMarkupHandler
- Parameters:
buffer
- the document buffer (not copied)nameOffset
- the offset (position in buffer) where the element name appears.nameLen
- the length (in chars) of the element name.line
- the line in the original document where the element ending structure appears.col
- the column in the original document where the element ending structure appears.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleInnerWhiteSpace
public void handleInnerWhiteSpace(char[] buffer, int offset, int len, int line, int col) throws ParseException
Description copied from interface:IAttributeSequenceHandler
Called when an amount of white space is found inside an element.
This attribute separators can contain any amount of whitespace, including line feeds:
<div id="main" class="basic_column">
[INNWSP]
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.
- Specified by:
handleInnerWhiteSpace
in interfaceIAttributeSequenceHandler
- Overrides:
handleInnerWhiteSpace
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
handleProcessingInstruction
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 ParseException
Description copied from interface:IProcessingInstructionHandler
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 through a different handling method.
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.
- Specified by:
handleProcessingInstruction
in interfaceIProcessingInstructionHandler
- Overrides:
handleProcessingInstruction
in classAbstractMarkupHandler
- Parameters:
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.- Throws:
ParseException
- if any exceptions occur during handling.
-
markCurrentSelection
private void markCurrentSelection()
-
unmarkCurrentSelection
private void unmarkCurrentSelection()
-
checkSizeOfMarkupBlocksStructure
private void checkSizeOfMarkupBlocksStructure(int markupLevel)
-
updateInsideAllSelectorMatchingBlockFlag
private void updateInsideAllSelectorMatchingBlockFlag()
-
-