org.attoparser.markup.html
Class AbstractDetailedNonValidatingHtmlAttoHandler

Object
  extended by org.attoparser.AbstractAttoHandler
      extended by org.attoparser.markup.AbstractBasicMarkupAttoHandler
          extended by org.attoparser.markup.AbstractDetailedMarkupAttoHandler
              extended by org.attoparser.markup.html.AbstractDetailedNonValidatingHtmlAttoHandler
All Implemented Interfaces:
IAttoHandler, ITimedDocumentHandling, IDetailedHtmlElementHandling, IHtmlAttributeSequenceHandling, IAttributeSequenceHandling, IBasicDocTypeHandling, IBasicElementHandling, ICDATASectionHandling, ICommentHandling, IDetailedDocTypeHandling, IDetailedElementHandling, IProcessingInstructionHandling, IXmlDeclarationHandling
Direct Known Subclasses:
AbstractStandardNonValidatingHtmlAttoHandler, HtmlCodeDisplayAttoHandler, TracingDetailedHtmlAttoHandler

public abstract class AbstractDetailedNonValidatingHtmlAttoHandler
extends AbstractDetailedMarkupAttoHandler
implements IDetailedHtmlElementHandling

Since:
1.1
Author:
Daniel Fernández

Constructor Summary
protected AbstractDetailedNonValidatingHtmlAttoHandler(HtmlParsingConfiguration configuration)
           
 
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 handleAutoCloseElementEnd(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 offset, int len, 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 handleCloseElementEnd(int line, int col)
           Called when the end 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 handleDocumentEnd(long endTimeNanos, long totalTimeNanos, int line, int col, HtmlParsingConfiguration parsingConfiguration)
           
 void handleDocumentEnd(long endTimeNanos, long totalTimeNanos, int line, int col, MarkupParsingConfiguration markupParsingConfiguration)
           Called when document parsing ends.
 void handleDocumentStart(long startTimeNanos, int line, int col, HtmlParsingConfiguration parsingConfiguration)
           
 void handleDocumentStart(long startTimeNanos, int line, int col, MarkupParsingConfiguration markupParsingConfiguration)
           Called when document parsing starts.
 void handleHtmlAttribute(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 handleHtmlCloseElementEnd(IHtmlElement element, int line, int col)
           Called when the end of a close element (a close tag) is found.
 void handleHtmlCloseElementStart(IHtmlElement element, char[] buffer, int nameOffset, int nameLen, int line, int col)
           Called when the start of a close element (a close tag) is found.
 void handleHtmlInnerWhiteSpace(char[] buffer, int offset, int len, int line, int col)
           Called when an amount of white space is found inside an element.
 void handleHtmlOpenElementEnd(IHtmlElement element, int line, int col)
           Called when the end of an open element (an open tag) is found.
 void handleHtmlOpenElementStart(IHtmlElement element, char[] buffer, int nameOffset, int nameLen, int line, int col)
           Called when the start of an open element (an open tag) is found.
 void handleHtmlStandaloneElementEnd(IHtmlElement element, boolean minimized, int line, int col)
           Called when the end of a standalone element is found.
 void handleHtmlStandaloneElementStart(IHtmlElement element, boolean minimized, char[] buffer, int nameOffset, int nameLen, int line, int col)
           Called when the start of a standalone element is found.
 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(int line, int col)
           Called when the end of an open element (an open tag) is found.
 void handleOpenElementStart(char[] buffer, int offset, int len, int line, int col)
           Called when an open element (an open tag) is found.
 void handleStandaloneElementEnd(int line, int col)
           Called when the end of a standalone element (a minimized tag) is found
 void handleStandaloneElementStart(char[] buffer, int offset, int len, int line, int col)
           Called when a standalone element (a minimized tag) is found.
 void handleUnmatchedCloseElementEnd(int line, int col)
           Called when the end of an unmatched close element (close tag) is found.
 void handleUnmatchedCloseElementStart(char[] buffer, int offset, int len, int line, int col)
           Called when the start of an unmatched close element (close tag) is found.
 
Methods inherited from class org.attoparser.markup.AbstractDetailedMarkupAttoHandler
handleCloseElement, handleDocType, handleDocType, handleDocumentEnd, handleDocumentStart, handleOpenElement, handleStandaloneElement, handleXmlDeclaration, handleXmlDeclarationDetail
 
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

AbstractDetailedNonValidatingHtmlAttoHandler

protected AbstractDetailedNonValidatingHtmlAttoHandler(HtmlParsingConfiguration configuration)
Method Detail

handleDocumentStart

public final void handleDocumentStart(long startTimeNanos,
                                      int line,
                                      int col,
                                      MarkupParsingConfiguration markupParsingConfiguration)
                               throws AttoParseException
Description copied from class: AbstractDetailedMarkupAttoHandler

Called when document parsing starts.

Overrides:
handleDocumentStart in class AbstractDetailedMarkupAttoHandler
Parameters:
startTimeNanos - the starting time, in nanoseconds.
markupParsingConfiguration - the document restrictions being applied.
Throws:
AttoParseException

handleDocumentEnd

public final void handleDocumentEnd(long endTimeNanos,
                                    long totalTimeNanos,
                                    int line,
                                    int col,
                                    MarkupParsingConfiguration markupParsingConfiguration)
                             throws AttoParseException
Description copied from class: AbstractDetailedMarkupAttoHandler

Called when document parsing ends.

Overrides:
handleDocumentEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
endTimeNanos - the parsing end time, in nanoseconds.
totalTimeNanos - the difference between parsing start and end times.
markupParsingConfiguration - the document restrictions being applied.
Throws:
AttoParseException

handleStandaloneElementStart

public final void handleStandaloneElementStart(char[] buffer,
                                               int offset,
                                               int len,
                                               int line,
                                               int col)
                                        throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called when a standalone element (a minimized 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 interface IDetailedElementHandling
Overrides:
handleStandaloneElementStart in class AbstractDetailedMarkupAttoHandler
Parameters:
buffer - the document buffer (not copied)
offset - the offset (position in buffer) where the element name appears.
len - 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:
AttoParseException

handleStandaloneElementEnd

public final void handleStandaloneElementEnd(int line,
                                             int col)
                                      throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called when the end of a standalone element (a minimized tag) is found

Specified by:
handleStandaloneElementEnd in interface IDetailedElementHandling
Overrides:
handleStandaloneElementEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
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:
AttoParseException

handleOpenElementStart

public final void handleOpenElementStart(char[] buffer,
                                         int offset,
                                         int len,
                                         int line,
                                         int col)
                                  throws AttoParseException
Description copied from interface: IDetailedElementHandling

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 interface IDetailedElementHandling
Overrides:
handleOpenElementStart in class AbstractDetailedMarkupAttoHandler
Parameters:
buffer - the document buffer (not copied)
offset - the offset (position in buffer) where the element name appears.
len - 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:
AttoParseException

handleOpenElementEnd

public final void handleOpenElementEnd(int line,
                                       int col)
                                throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called when the end of an open element (an open tag) is found.

Specified by:
handleOpenElementEnd in interface IDetailedElementHandling
Overrides:
handleOpenElementEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
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:
AttoParseException

handleCloseElementStart

public final void handleCloseElementStart(char[] buffer,
                                          int offset,
                                          int len,
                                          int line,
                                          int col)
                                   throws AttoParseException
Description copied from interface: IDetailedElementHandling

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 interface IDetailedElementHandling
Overrides:
handleCloseElementStart in class AbstractDetailedMarkupAttoHandler
Parameters:
buffer - the document buffer (not copied)
offset - the offset (position in buffer) where the element name appears.
len - 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:
AttoParseException

handleCloseElementEnd

public final void handleCloseElementEnd(int line,
                                        int col)
                                 throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called when the end of a close element (a close tag) is found.

Specified by:
handleCloseElementEnd in interface IDetailedElementHandling
Overrides:
handleCloseElementEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
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:
AttoParseException

handleAutoCloseElementStart

public final void handleAutoCloseElementStart(char[] buffer,
                                              int offset,
                                              int len,
                                              int line,
                                              int col)
                                       throws AttoParseException
Description copied from interface: IDetailedElementHandling

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 interface IDetailedElementHandling
Overrides:
handleAutoCloseElementStart in class AbstractDetailedMarkupAttoHandler
Parameters:
buffer - the document buffer (not copied)
offset - the offset (position in buffer) where the element name appears.
len - 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:
AttoParseException

handleAutoCloseElementEnd

public final void handleAutoCloseElementEnd(int line,
                                            int col)
                                     throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called for signaling the end of an auto-close element, created for balancing an unclosed tag.

Specified by:
handleAutoCloseElementEnd in interface IDetailedElementHandling
Overrides:
handleAutoCloseElementEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
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:
AttoParseException

handleUnmatchedCloseElementStart

public final void handleUnmatchedCloseElementStart(char[] buffer,
                                                   int offset,
                                                   int len,
                                                   int line,
                                                   int col)
                                            throws AttoParseException
Description copied from interface: IDetailedElementHandling

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 interface IDetailedElementHandling
Overrides:
handleUnmatchedCloseElementStart in class AbstractDetailedMarkupAttoHandler
Parameters:
buffer - the document buffer (not copied)
offset - the offset (position in buffer) where the element name appears.
len - 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:
AttoParseException

handleUnmatchedCloseElementEnd

public final void handleUnmatchedCloseElementEnd(int line,
                                                 int col)
                                          throws AttoParseException
Description copied from interface: IDetailedElementHandling

Called when the end of an unmatched close element (close tag) is found.

Specified by:
handleUnmatchedCloseElementEnd in interface IDetailedElementHandling
Overrides:
handleUnmatchedCloseElementEnd in class AbstractDetailedMarkupAttoHandler
Parameters:
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:
AttoParseException

handleAttribute

public final 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
Description copied from interface: 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.

Specified by:
handleAttribute in interface IAttributeSequenceHandling
Overrides:
handleAttribute in class AbstractDetailedMarkupAttoHandler
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:
AttoParseException

handleInnerWhiteSpace

public final void handleInnerWhiteSpace(char[] buffer,
                                        int offset,
                                        int len,
                                        int line,
                                        int col)
                                 throws AttoParseException
Description copied from interface: IAttributeSequenceHandling

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">
              [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.

Specified by:
handleInnerWhiteSpace in interface IAttributeSequenceHandling
Overrides:
handleInnerWhiteSpace in class AbstractDetailedMarkupAttoHandler
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:
AttoParseException

handleDocumentStart

public void handleDocumentStart(long startTimeNanos,
                                int line,
                                int col,
                                HtmlParsingConfiguration parsingConfiguration)
                         throws AttoParseException
Throws:
AttoParseException

handleDocumentEnd

public void handleDocumentEnd(long endTimeNanos,
                              long totalTimeNanos,
                              int line,
                              int col,
                              HtmlParsingConfiguration parsingConfiguration)
                       throws AttoParseException
Throws:
AttoParseException

handleHtmlStandaloneElementStart

public void handleHtmlStandaloneElementStart(IHtmlElement element,
                                             boolean minimized,
                                             char[] buffer,
                                             int nameOffset,
                                             int nameLen,
                                             int line,
                                             int col)
                                      throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the start of a standalone element is found.

A standalone element can be either a minimized tag or not. For example: <img src="..." /> is minimized (self-closed), as opposed to <img src="..."> (non-minimized, perfectly valid from the HTML but not from the XML or XHTML standpoints).

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:
handleHtmlStandaloneElementStart in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
minimized - whether the tag representing this element is minimized (self-closed) or not.
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:
AttoParseException

handleHtmlStandaloneElementEnd

public void handleHtmlStandaloneElementEnd(IHtmlElement element,
                                           boolean minimized,
                                           int line,
                                           int col)
                                    throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the end of a standalone element is found.

Specified by:
handleHtmlStandaloneElementEnd in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
minimized - whether the tag representing this element is minimized (self-closed) 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:
AttoParseException

handleHtmlOpenElementStart

public void handleHtmlOpenElementStart(IHtmlElement element,
                                       char[] buffer,
                                       int nameOffset,
                                       int nameLen,
                                       int line,
                                       int col)
                                throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the start 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:
handleHtmlOpenElementStart in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
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:
AttoParseException

handleHtmlOpenElementEnd

public void handleHtmlOpenElementEnd(IHtmlElement element,
                                     int line,
                                     int col)
                              throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the end of an open element (an open tag) is found.

Specified by:
handleHtmlOpenElementEnd in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
line - the line in the original document where this artifact starts.
col - the column in the original document where this artifact starts.
Throws:
AttoParseException

handleHtmlCloseElementStart

public void handleHtmlCloseElementStart(IHtmlElement element,
                                        char[] buffer,
                                        int nameOffset,
                                        int nameLen,
                                        int line,
                                        int col)
                                 throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the start 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:
handleHtmlCloseElementStart in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
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:
AttoParseException

handleHtmlCloseElementEnd

public void handleHtmlCloseElementEnd(IHtmlElement element,
                                      int line,
                                      int col)
                               throws AttoParseException
Description copied from interface: IDetailedHtmlElementHandling

Called when the end of a close element (a close tag) is found.

Specified by:
handleHtmlCloseElementEnd in interface IDetailedHtmlElementHandling
Parameters:
element - the IHtmlElement element object representing the corresponding HTML element.
line - the line in the original document where this artifact starts.
col - the column in the original document where this artifact starts.
Throws:
AttoParseException

handleHtmlAttribute

public void handleHtmlAttribute(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
Description copied from interface: IHtmlAttributeSequenceHandling

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:
handleHtmlAttribute in interface IHtmlAttributeSequenceHandling
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:
AttoParseException

handleHtmlInnerWhiteSpace

public void handleHtmlInnerWhiteSpace(char[] buffer,
                                      int offset,
                                      int len,
                                      int line,
                                      int col)
                               throws AttoParseException
Description copied from interface: IHtmlAttributeSequenceHandling

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">
              [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.

Specified by:
handleHtmlInnerWhiteSpace in interface IHtmlAttributeSequenceHandling
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:
AttoParseException


Copyright © 2012 The ATTOPARSER team. All Rights Reserved.