FormattingAppendable (flexmark-java utilities 0.40.32 API)

All Superinterfaces:

Appendable

All Known Subinterfaces:

HtmlFormattingAppendable

All Known Implementing Classes:

FormattingAppendableImpl, HtmlBuilder, HtmlFormattingAppendableBase
```
public interface FormattingAppendable
extends Appendable
```
Used to intercept appended text and format it for indents, control output of new lines limiting them to terminate text but not create blank lines, and control number of blank lines output, eliminate spaces before and after \n, other than indents controlled by this class.
consecutive \n in the data are going go be collapsed to a single \n and which will only be output when text is appended after the \n, or on flush() call to output any pending \n's
tab is converted to a space spaces before and after \n are removed since indentation is controlled by this class through the indent() and unIndent() members. optionally will collapse multiple spaces to one space
Indent is only output after a \n and before text. Blank lines and other \n's do not output an indent use line(), lineIf(boolean), blankLine(), blankLineIf(boolean) and blankLine(int) for getting these in the appended result
Also adds conditional new line and indent capability, allowing compact form if there is no "child" element data output, and fully unfolded, indented form if there is "child" element text output.
For example output of HTML list items in compact form as <li>item text</li> if it has no children and as split over several lines, with child content indented, if it has children: <li>item text child text </li>

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALLOW_LEADING_WHITESPACE`
`static int`	`COLLAPSE_WHITESPACE`
`static int`	`CONVERT_TABS`
`static int`	`FORMAT_ALL`
`static int`	`PASS_THROUGH`
`static int`	`PREFIX_AFTER_PENDING_EOL`
`static int`	`SUPPRESS_TRAILING_WHITESPACE`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`FormattingAppendable`	`addAfterEolRunnable(int atPendingEOL, Runnable runnable)` Add runnable to run after the given pending EOL is output to the stream.
`FormattingAppendable`	`addLine()` Add a new line or blank lines as needed.
`FormattingAppendable`	`addPrefix(CharSequence prefix)` Set prefix to append after a new line character for every line before the indent prefix in normal and after a new line in pre-formatted sections This appends the sequence to current prefix
`FormattingAppendable`	`append(char c)`
`FormattingAppendable`	`append(CharSequence csq)`
`FormattingAppendable`	`append(CharSequence csq, int start, int end)`
`FormattingAppendable`	`blankLine()` Add a blank line, if there is not one already appended.
`FormattingAppendable`	`blankLine(int count)` Add a blank lines, if there isn't already given number of blank lines appended.
`FormattingAppendable`	`blankLineIf(boolean predicate)` Add a blank line, if predicate is true and there isn't already blank lines appended.
`FormattingAppendable`	`closeConditional(ConditionalFormatter closeFormatter)` Close a conditional formatting region.
`FormattingAppendable`	`closePreFormatted()` Close a pre-formatted section.
`int`	`column()` Get column offset after last append, does not include any pending: EOLs, spaces nor indents
`int`	`columnWith(CharSequence csq, int start, int end)` Get column offset after last append, does not include any pending: EOLs, spaces nor indents
`FormattingAppendable`	`flush()` Flush all pending new lines, no blank lines will be output, if these are desired at the end of the output.
`FormattingAppendable`	`flush(int maxBlankLines)` Flush all pending new lines and blank lines, if these are desired at the end of the output.
`FormattingAppendable`	`flushWhitespaces()` Flush all pending whitespaces
`Appendable`	`getAppendable()` Get the underlying appendable
`int`	`getIndent()` Get the current indent level + indent offset
`CharSequence`	`getIndentPrefix()` Get prefix appended after a new line character for every indent level
`IOException`	`getIOException()`
`int`	`getLineCount()` Get the number of lines appended, does not include pending: EOLs
`int`	`getModCount()` Get the modification count.
`int`	`getOptions()` Get current options
`int`	`getPendingEOL()` see if there is a pending space
`int`	`getPendingSpace()`
`CharSequence`	`getPrefix()` Get prefix being applied to all lines, even in pre-formatted sections
`int`	`getPushedPrefixCount()` Pop a prefix from the stack and set the current prefix
`String`	`getText()` get the resulting text from appendable
`String`	`getText(int maxBlankLines)` get the resulting text from appendable
`CharSequence`	`getTotalIndentPrefix()` Get the total indent prefix appended after a new line character, `getIndentPrefix()` repeated `getIndent()` times.
`FormattingAppendable`	`indent()` Increase the indent level, will terminate the current line if there is unterminated text
`boolean`	`isPendingEOL()` see if there is a pending space
`boolean`	`isPendingSpace()` see if there is a pending space
`boolean`	`isPreFormatted()`
`int`	`lastOffset()` Get offset before the last append, but right after pending: EOLs, spaces or indents were added
`FormattingAppendable`	`lastOffset(Ref<Integer> refOffset)` Get offset before the next append, but right after pending: EOLs, spaces or indents were added Next append of text (non EOL/spaces) will set the reference, following appends will have not effect Unlike `lastOffset()` flush() does not change the value of the reference, only actual character appending.
`FormattingAppendable`	`line()` Add a new line, if there was any unterminated text appended
`FormattingAppendable`	`line(Ref<Boolean> lineRef)` Add a new line, if there was any unterminated text appended
`FormattingAppendable`	`lineIf(boolean predicate)` Add a new line, if predicate is true and there was any unterminated text appended
`FormattingAppendable`	`lineIf(Ref<Boolean> lineRef)` Add a new line, if lineRef is true, if false means that the new line in `line(Ref)` was suppressed by conditionalFormatter and this new line will be suppressed too.
`int`	`offset()` Get offset after last append, does not include any pending: EOLs, spaces nor indents
`int`	`offsetWithPending()` Get offset after last append, include any pending: EOLs, and indents
`FormattingAppendable`	`openConditional(ConditionalFormatter openFormatter)` Open a conditional formatting region.
`FormattingAppendable`	`openPreFormatted(boolean keepIndent)` Open a pre-formatted section.
`FormattingAppendable`	`popPrefix()` Pop a prefix from the stack and set the current prefix
`FormattingAppendable`	`pushPrefix()` Save the current prefix on the stack
`FormattingAppendable`	`repeat(char c, int count)`
`FormattingAppendable`	`repeat(CharSequence csq, int count)`
`FormattingAppendable`	`repeat(CharSequence csq, int start, int end, int count)`
`FormattingAppendable`	`setIndentOffset(int indentOffset)` Set the current indent level.
`FormattingAppendable`	`setIndentPrefix(CharSequence prefix)` Set prefix to append after a new line character for every indent level
`FormattingAppendable`	`setOptions(int options)` Set options on processing text
`void`	`setPendingEOL(int pendingEOL)` Kludge to allow inserting spaces before the already pending EOL in HTML parser
`FormattingAppendable`	`setPrefix(CharSequence prefix)` Set prefix to append after a new line character for every line before the indent prefix in normal and after a new line in pre-formatted sections if PREFIX_AFTER_PENDING_EOL is enabled then prefix will take effect after pending EOLs are output
`FormattingAppendable`	`unIndent()` Decrease the indent level, min level is 0, will terminate the current line if there is unterminated text
`FormattingAppendable`	`willIndent()` Notify of the fact that after some appending some text, there will be an indent() call so that conditional formatting can kick in before the text is appended

- Field Detail
  - CONVERT_TABS
```
static final int CONVERT_TABS
```
    See Also:
    
    Constant Field Values
  - COLLAPSE_WHITESPACE
```
static final int COLLAPSE_WHITESPACE
```
    See Also:
    
    Constant Field Values
  - SUPPRESS_TRAILING_WHITESPACE
```
static final int SUPPRESS_TRAILING_WHITESPACE
```
    See Also:
    
    Constant Field Values
  - PREFIX_AFTER_PENDING_EOL
```
static final int PREFIX_AFTER_PENDING_EOL
```
    See Also:
    
    Constant Field Values
  - PASS_THROUGH
```
static final int PASS_THROUGH
```
    See Also:
    
    Constant Field Values
  - ALLOW_LEADING_WHITESPACE
```
static final int ALLOW_LEADING_WHITESPACE
```
    See Also:
    
    Constant Field Values
  - FORMAT_ALL
```
static final int FORMAT_ALL
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getIOException
```
IOException getIOException()
```
  - append
```
FormattingAppendable append(CharSequence csq)
```
    Specified by:
    
    append in interface Appendable
  - append
```
FormattingAppendable append(CharSequence csq,
                            int start,
                            int end)
```
    Specified by:
    
    append in interface Appendable
  - append
```
FormattingAppendable append(char c)
```
    Specified by:
    
    append in interface Appendable
  - repeat
```
FormattingAppendable repeat(char c,
                            int count)
```
  - repeat
```
FormattingAppendable repeat(CharSequence csq,
                            int count)
```
  - repeat
```
FormattingAppendable repeat(CharSequence csq,
                            int start,
                            int end,
                            int count)
```
  - getAppendable
```
Appendable getAppendable()
```
    Get the underlying appendable
    
    Returns:
    
    appendable being used for accumulating output
  - getText
```
String getText()
```
    get the resulting text from appendable
    
    Returns:
    
    appendable toString() result after flushing
  - getText
```
String getText(int maxBlankLines)
```
    get the resulting text from appendable
    
    Parameters:
    
    maxBlankLines - maximum blank lines to allow at end, -1 will suppress the last EOL
    
    Returns:
    
    appendable toString() result after flushing
  - getOptions
```
int getOptions()
```
    Get current options
    
    Returns:
    
    option flags
  - setOptions
```
FormattingAppendable setOptions(int options)
```
    Set options on processing text
    
    Parameters:
    
    options - option flags
    
    Returns:
    
    this
  - flush
```
FormattingAppendable flush()
```
    Flush all pending new lines, no blank lines will be output, if these are desired at the end of the output.
    All preFormatted and conditional regions should be exited prior to this call
    
    Returns:
    
    this
  - flushWhitespaces
```
FormattingAppendable flushWhitespaces()
```
    Flush all pending whitespaces
    All preFormatted and conditional regions should be exited prior to this call
    
    Returns:
    
    this
  - flush
```
FormattingAppendable flush(int maxBlankLines)
```
    Flush all pending new lines and blank lines, if these are desired at the end of the output.
    All preFormatted and conditional regions should be exited prior to this call
    
    Parameters:
    
    maxBlankLines - maximum blank lines to allow at end, -1 will suppress the last EOL
    
    Returns:
    
    this
  - getIndentPrefix
```
CharSequence getIndentPrefix()
```
    Get prefix appended after a new line character for every indent level
    
    Returns:
    
    char sequence of the current indent prefix used for each indent level
  - getTotalIndentPrefix
```
CharSequence getTotalIndentPrefix()
```
    Get the total indent prefix appended after a new line character, getIndentPrefix() repeated getIndent() times.
    
    Returns:
    
    char sequence of the current indent prefix used for each indent level
  - setIndentPrefix
```
FormattingAppendable setIndentPrefix(CharSequence prefix)
```
    Set prefix to append after a new line character for every indent level
    
    Parameters:
    
    prefix - prefix characters for new lines appended after this is set
    
    Returns:
    
    this
  - getPrefix
```
CharSequence getPrefix()
```
    Get prefix being applied to all lines, even in pre-formatted sections
    
    Returns:
    
    char sequence of the current prefix
  - setPrefix
```
FormattingAppendable setPrefix(CharSequence prefix)
```
    Set prefix to append after a new line character for every line before the indent prefix in normal and after a new line in pre-formatted sections if PREFIX_AFTER_PENDING_EOL is enabled then prefix will take effect after pending EOLs are output
    
    Parameters:
    
    prefix - prefix characters for new lines appended after this is set
    
    Returns:
    
    this
  - addPrefix
```
FormattingAppendable addPrefix(CharSequence prefix)
```
    Set prefix to append after a new line character for every line before the indent prefix in normal and after a new line in pre-formatted sections This appends the sequence to current prefix
    
    Parameters:
    
    prefix - prefix characters to add to current prefix for new lines appended after this is set
    
    Returns:
    
    this
  - pushPrefix
```
FormattingAppendable pushPrefix()
```
    Save the current prefix on the stack
    
    Returns:
    
    this
  - popPrefix
```
FormattingAppendable popPrefix()
```
    Pop a prefix from the stack and set the current prefix
    
    Returns:
    
    this
  - setPendingEOL
```
void setPendingEOL(int pendingEOL)
```
    Kludge to allow inserting spaces before the already pending EOL in HTML parser
    
    Parameters:
    
    pendingEOL - how many pending EOLs to set
  - addAfterEolRunnable
```
FormattingAppendable addAfterEolRunnable(int atPendingEOL,
                                         Runnable runnable)
```
    Add runnable to run after the given pending EOL is output to the stream. if current pendingEOL is N then will run after pendingEOL == atPendingEOL and EOL is output
    
    Parameters:
    
    atPendingEOL - pending EOL level
    
    runnable - runnable to run once this EOL is output
    
    Returns:
    
    this
  - getPushedPrefixCount
```
int getPushedPrefixCount()
```
    Pop a prefix from the stack and set the current prefix
    
    Returns:
    
    count of prefixes on stack
  - line
```
FormattingAppendable line()
```
    Add a new line, if there was any unterminated text appended
    Actual new line character is only appended if there is real data appended and it did not contain a new line as the last character
    
    Returns:
    
    this
  - addLine
```
FormattingAppendable addLine()
```
    Add a new line or blank lines as needed.
    Actual new line character is only appended if there is real data appended and it did not contain a new line as the last character
    
    Returns:
    
    this
  - lineIf
```
FormattingAppendable lineIf(boolean predicate)
```
    Add a new line, if predicate is true and there was any unterminated text appended
    Actual new line character is only appended if and when text is appended appended and it did not contain a new line as the last character
    
    Parameters:
    
    predicate - if true then new line will be started
    
    Returns:
    
    this
  - line
```
FormattingAppendable line(Ref<Boolean> lineRef)
```
    Add a new line, if there was any unterminated text appended
    Actual new line character is only appended if there is real data appended and it did not contain a new line as the last character
    
    Parameters:
    
    lineRef - predicate storage will be set to false if conditionalFormatter suppressed a new line
    
    Returns:
    
    this
  - lineIf
```
FormattingAppendable lineIf(Ref<Boolean> lineRef)
```
    Add a new line, if lineRef is true, if false means that the new line in line(Ref) was suppressed by conditionalFormatter and this new line will be suppressed too.
    Actual new line character is only appended if and when text is appended appended and it did not contain a new line as the last character
    
    Parameters:
    
    lineRef - predicate storage for conditionalFormatter suppressed new line condition
    
    Returns:
    
    this
  - blankLine
```
FormattingAppendable blankLine()
```
    Add a blank line, if there is not one already appended.
    Actual blank line characters are only appended if there is real data appended and it did not contain a blank line as the last part of its text
    
    Returns:
    
    this
  - blankLineIf
```
FormattingAppendable blankLineIf(boolean predicate)
```
    Add a blank line, if predicate is true and there isn't already blank lines appended.
    Actual blank line characters are only appended if and when there text is appended appended and it did not contain a blank line as the last part of its text
    
    Parameters:
    
    predicate - when true append blank line
    
    Returns:
    
    this
  - blankLine
```
FormattingAppendable blankLine(int count)
```
    Add a blank lines, if there isn't already given number of blank lines appended. Will append only enough blank lines to increase it to given level. If more are already in the wings then nothing is done.
    On real data being appended, will append enough new lines to ensure that there are given number of blank lines between previous append and the next one.
    Actual blank line characters are only appended if there is real data appended and it did not contain a blank line as the last part of its text
    
    Parameters:
    
    count - number of blank lines to append
    
    Returns:
    
    this
  - getIndent
```
int getIndent()
```
    Get the current indent level + indent offset
    
    Returns:
    
    indent level
  - setIndentOffset
```
FormattingAppendable setIndentOffset(int indentOffset)
```
    Set the current indent level. Not for indenting use. This does not do any calls or validation. Intended use is to set initial indent
    
    Parameters:
    
    indentOffset - minimum indent that will be used
    
    Returns:
    
    this
  - indent
```
FormattingAppendable indent()
```
    Increase the indent level, will terminate the current line if there is unterminated text
    
    Returns:
    
    this
  - willIndent
```
FormattingAppendable willIndent()
```
    Notify of the fact that after some appending some text, there will be an indent() call so that conditional formatting can kick in before the text is appended
    
    Returns:
    
    this
  - unIndent
```
FormattingAppendable unIndent()
```
    Decrease the indent level, min level is 0, will terminate the current line if there is unterminated text
    
    Returns:
    
    this
  - getModCount
```
int getModCount()
```
    Get the modification count. Incremented every time there is actual text appended
    
    Returns:
    
    modification count
  - getLineCount
```
int getLineCount()
```
    Get the number of lines appended, does not include pending: EOLs
    
    Returns:
    
    number of lines appended
  - lastOffset
```
FormattingAppendable lastOffset(Ref<Integer> refOffset)
```
    Get offset before the next append, but right after pending: EOLs, spaces or indents were added Next append of text (non EOL/spaces) will set the reference, following appends will have not effect Unlike lastOffset() flush() does not change the value of the reference, only actual character appending.
    
    Parameters:
    
    refOffset - reference where to store offset, if no appending was done then value is not changed
    
    Returns:
    
    this
  - lastOffset
```
int lastOffset()
```
    Get offset before the last append, but right after pending: EOLs, spaces or indents were added
    
    Returns:
    
    character offset before last append or flush
  - offset
```
int offset()
```
    Get offset after last append, does not include any pending: EOLs, spaces nor indents
    
    Returns:
    
    character offset after last append or flush
  - offsetWithPending
```
int offsetWithPending()
```
    Get offset after last append, include any pending: EOLs, and indents
    
    Returns:
    
    character offset after last append or flush
  - column
```
int column()
```
    Get column offset after last append, does not include any pending: EOLs, spaces nor indents
    
    Returns:
    
    column offset after last append or flush from previous EOL
  - columnWith
```
int columnWith(CharSequence csq,
               int start,
               int end)
```
    Get column offset after last append, does not include any pending: EOLs, spaces nor indents
    
    Parameters:
    
    csq - sequence to use for computation
    
    start - start offset in csq
    
    end - end offset in csq
    
    Returns:
    
    column offset which would result from appending csq
  - openPreFormatted
```
FormattingAppendable openPreFormatted(boolean keepIndent)
```
    Open a pre-formatted section. No monitoring of text is done, all text is output as is while nesting count >0
    
    Parameters:
    
    keepIndent - if true, if there is pending indent it will be appended before entering pre-format mode
    
    Returns:
    
    this
  - closePreFormatted
```
FormattingAppendable closePreFormatted()
```
    Close a pre-formatted section. No monitoring of text is done, all text is output as is while nesting count >0
    
    Returns:
    
    this
  - isPreFormatted
```
boolean isPreFormatted()
```
    Returns:
    
    true if in pre-formatted region
  - openConditional
```
FormattingAppendable openConditional(ConditionalFormatter openFormatter)
```
    Open a conditional formatting region.
    After opening if and when text is appended the ConditionalFormatter.apply(boolean, boolean, boolean, boolean) will be invoked before appending the text with parameters specifying whether indent or line were invoked before appending text. The onText is always true for opening conditional formatter or the apply() method would not be called
    the firstAppend will be set if this is the first call, if onIndent is false on first call then the apply() method will be invoked again if any indent() is performed before the conditional is closed.
    
    Parameters:
    
    openFormatter - to invoke before text is appended
    
    Returns:
    
    this
  - closeConditional
```
FormattingAppendable closeConditional(ConditionalFormatter closeFormatter)
```
    Close a conditional formatting region.
    ConditionalFormatter.apply(boolean, boolean, boolean, boolean) will be invoked with parameters specifying whether indent, line or text was appended when openConditional(ConditionalFormatter) invoked before appending text. If onText is false then openFormatter passed to openConditional(ConditionalFormatter) was not invoked.
    
    Parameters:
    
    closeFormatter - to invoke with parameters informing with what parameters the openFormatter was invoked, if at all
    
    Returns:
    
    this
  - isPendingSpace
```
boolean isPendingSpace()
```
    see if there is a pending space
    
    Returns:
    
    true if space is pending
  - getPendingSpace
```
int getPendingSpace()
```
  - isPendingEOL
```
boolean isPendingEOL()
```
    see if there is a pending space
    
    Returns:
    
    true if space is pending
  - getPendingEOL
```
int getPendingEOL()
```
    see if there is a pending space
    
    Returns:
    
    number of pending EOLs

Interface FormattingAppendable

Field Summary

Method Summary

Field Detail

CONVERT_TABS

COLLAPSE_WHITESPACE

SUPPRESS_TRAILING_WHITESPACE

PREFIX_AFTER_PENDING_EOL

PASS_THROUGH

ALLOW_LEADING_WHITESPACE

FORMAT_ALL

Method Detail

getIOException

append

append

append

repeat

repeat

repeat

getAppendable

getText

getText

getOptions

setOptions

flush

flushWhitespaces

flush

getIndentPrefix

getTotalIndentPrefix

setIndentPrefix

getPrefix

setPrefix

addPrefix

pushPrefix

popPrefix

setPendingEOL

addAfterEolRunnable

getPushedPrefixCount

line

addLine

lineIf

line

lineIf

blankLine

blankLineIf

blankLine

getIndent

setIndentOffset

indent

willIndent

unIndent

getModCount

getLineCount

lastOffset

lastOffset

offset

offsetWithPending

column

columnWith

openPreFormatted

closePreFormatted

isPreFormatted

openConditional

closeConditional

isPendingSpace

getPendingSpace

isPendingEOL

getPendingEOL