HtmlFormattingAppendableBase (flexmark-java utilities 0.26.4 API)

java.lang.Object
- com.vladsch.flexmark.util.html.HtmlFormattingAppendableBase<T>

All Implemented Interfaces:: FormattingAppendable, HtmlFormattingAppendable, Appendable

public class HtmlFormattingAppendableBase<T extends HtmlFormattingAppendableBase>
extends Object
implements HtmlFormattingAppendable

Field Summary
- Fields inherited from interface com.vladsch.flexmark.util.html.FormattingAppendable
  COLLAPSE_WHITESPACE, CONVERT_TABS, FORMAT_ALL, PREFIX_AFTER_PENDING_EOL, SUPPRESS_TRAILING_WHITESPACE

Constructor Summary

Constructors
Constructor and Description
`HtmlFormattingAppendableBase(Appendable out)`
`HtmlFormattingAppendableBase(Appendable out, int indentSize, boolean allFormatOptions)`
`HtmlFormattingAppendableBase(Appendable out, int indentSize, int formatOptions)`
`HtmlFormattingAppendableBase(FormattingAppendable other, Appendable out, boolean inheritIndent)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`T`	`addAfterEolRunnable(int atPendingEOL, Runnable runnable)` Add runnable to run after the given pending EOL is output to the stream.
`T`	`addLine()` Add a new line or blank lines as needed.
`T`	`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
`T`	`append(char c)`
`T`	`append(CharSequence csq)`
`T`	`append(CharSequence csq, int start, int end)`
`T`	`attr(Attribute... attribute)`
`T`	`attr(Attributes attributes)`
`T`	`attr(CharSequence attrName, CharSequence value)`
`T`	`blankLine()` Add a blank line, if there is not one already appended.
`T`	`blankLine(int count)` Add a blank lines, if there isn't already given number of blank lines appended.
`T`	`blankLineIf(boolean predicate)` Add a blank line, if predicate is true and there isn't already blank lines appended.
`T`	`closeConditional(ConditionalFormatter closeFormatter)` Close a conditional formatting region.
`T`	`closePre()`
`T`	`closePreFormatted()` Close a pre-formatted section.
`T`	`closeTag(CharSequence tagName)`
`T`	`flush()` Flush all pending new lines, no blank lines will be output, if these are desired at the end of the output.
`T`	`flush(int maxBlankLines)` Flush all pending new lines and blank lines, if these are desired at the end of the output.
`T`	`flushWhitespaces()` Flush all pending whitespaces
`Appendable`	`getAppendable()` Get the underlying appendable
`Attributes`	`getAttributes()`
`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.
`Stack<String>`	`getOpenTags()`
`List<String>`	`getOpenTagsAfterLast(CharSequence latestTag)`
`protected String`	`getOpenTagText()`
`int`	`getOptions()` Get current options
`int`	`getPendingEOL()` see if there is a pending space
`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, `FormattingAppendable.getIndentPrefix()` repeated `FormattingAppendable.getIndent()` times.
`T`	`indent()` Increase the indent level, will terminate the current line if there is unterminated text
`boolean`	`inPre()`
`boolean`	`isPendingEOL()` see if there is a pending space
`boolean`	`isPendingSpace()` see if there is a pending space
`boolean`	`isPreFormatted()`
`boolean`	`isSuppressCloseTagLine()`
`boolean`	`isSuppressOpenTagLine()`
`int`	`lastOffset()` Get offset before the last append, but right after pending: EOLs, spaces or indents were added
`T`	`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 `FormattingAppendable.lastOffset()` flush() does not change the value of the reference, only actual character appending.
`T`	`line()` Add a new line, if there was any unterminated text appended
`T`	`line(Ref<Boolean> lineRef)` Add a new line, if there was any unterminated text appended
`T`	`lineIf(boolean predicate)` Add a new line, if predicate is true and there was any unterminated text appended
`T`	`lineIf(Ref<Boolean> lineRef)` Add a new line, if lineRef is true, if false means that the new line in `FormattingAppendable.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
`T`	`openConditional(ConditionalFormatter openFormatter)` Open a conditional formatting region.
`T`	`openPre()`
`T`	`openPreFormatted(boolean keepIndent)` Open a pre-formatted section.
`T`	`popPrefix()` Pop a prefix from the stack and set the current prefix
`protected void`	`popTag(CharSequence tagName)`
`T`	`pushPrefix()` Save the current prefix on the stack
`protected void`	`pushTag(CharSequence tagName)`
`T`	`raw(CharSequence s)`
`T`	`raw(CharSequence s, int count)`
`T`	`rawIndentedPre(CharSequence s)`
`T`	`rawPre(CharSequence s)`
`T`	`repeat(char c, int count)`
`T`	`repeat(CharSequence csq, int count)`
`T`	`repeat(CharSequence csq, int start, int end, int count)`
`T`	`setAttributes(Attributes attributes)`
`T`	`setIndentOffset(int indentOffset)` Set the current indent level.
`T`	`setIndentPrefix(CharSequence prefix)` Set prefix to append after a new line character for every indent level
`T`	`setOptions(int options)` Set options on processing text
`T`	`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
`T`	`setSuppressCloseTagLine(boolean suppressCloseTagLine)`
`void`	`setSuppressOpenTagLine(boolean suppressOpenTagLine)`
`T`	`tag(CharSequence tagName)`
`T`	`tag(CharSequence tagName, boolean voidElement)`
`T`	`tag(CharSequence tagName, boolean withIndent, boolean withLine, Runnable runnable)`
`protected void`	`tagClosed(CharSequence tagName)`
`T`	`tagIndent(CharSequence tagName, Runnable runnable)`
`T`	`tagLine(CharSequence tagName)`
`T`	`tagLine(CharSequence tagName, boolean voidElement)`
`T`	`tagLine(CharSequence tagName, Runnable runnable)`
`T`	`tagLineIndent(CharSequence tagName, Runnable runnable)`
`protected void`	`tagOpened(CharSequence tagName)`
`T`	`tagVoid(CharSequence tagName)`
`T`	`tagVoidLine(CharSequence tagName)`
`T`	`text(CharSequence s)`
`T`	`unIndent()` Decrease the indent level, min level is 0, will terminate the current line if there is unterminated text
`T`	`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
`T`	`withAttr()`
`T`	`withCondIndent()`
`T`	`withCondLine()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - HtmlFormattingAppendableBase
```
public HtmlFormattingAppendableBase(Appendable out)
```
  - HtmlFormattingAppendableBase
```
public HtmlFormattingAppendableBase(FormattingAppendable other,
                                    Appendable out,
                                    boolean inheritIndent)
```
  - HtmlFormattingAppendableBase
```
public HtmlFormattingAppendableBase(Appendable out,
                                    int indentSize,
                                    boolean allFormatOptions)
```
  - HtmlFormattingAppendableBase
```
public HtmlFormattingAppendableBase(Appendable out,
                                    int indentSize,
                                    int formatOptions)
```
- Method Detail
  - isSuppressOpenTagLine
```
public boolean isSuppressOpenTagLine()
```
  - setSuppressOpenTagLine
```
public void setSuppressOpenTagLine(boolean suppressOpenTagLine)
```
  - isSuppressCloseTagLine
```
public boolean isSuppressCloseTagLine()
```
  - setSuppressCloseTagLine
```
public T setSuppressCloseTagLine(boolean suppressCloseTagLine)
```
  - openPre
```
public T openPre()
```
    Specified by:
    
    openPre in interface HtmlFormattingAppendable
  - closePre
```
public T closePre()
```
    Specified by:
    
    closePre in interface HtmlFormattingAppendable
  - inPre
```
public boolean inPre()
```
    Specified by:
    
    inPre in interface HtmlFormattingAppendable
  - raw
```
public T raw(CharSequence s)
```
    Specified by:
    
    raw in interface HtmlFormattingAppendable
  - raw
```
public T raw(CharSequence s,
             int count)
```
    Specified by:
    
    raw in interface HtmlFormattingAppendable
  - rawPre
```
public T rawPre(CharSequence s)
```
    Specified by:
    
    rawPre in interface HtmlFormattingAppendable
  - rawIndentedPre
```
public T rawIndentedPre(CharSequence s)
```
    Specified by:
    
    rawIndentedPre in interface HtmlFormattingAppendable
  - text
```
public T text(CharSequence s)
```
    Specified by:
    
    text in interface HtmlFormattingAppendable
  - attr
```
public T attr(CharSequence attrName,
              CharSequence value)
```
    Specified by:
    
    attr in interface HtmlFormattingAppendable
  - attr
```
public T attr(Attribute... attribute)
```
    Specified by:
    
    attr in interface HtmlFormattingAppendable
  - attr
```
public T attr(Attributes attributes)
```
    Specified by:
    
    attr in interface HtmlFormattingAppendable
  - withAttr
```
public T withAttr()
```
    Specified by:
    
    withAttr in interface HtmlFormattingAppendable
  - getAttributes
```
public Attributes getAttributes()
```
    Specified by:
    
    getAttributes in interface HtmlFormattingAppendable
  - setAttributes
```
public T setAttributes(Attributes attributes)
```
    Specified by:
    
    setAttributes in interface HtmlFormattingAppendable
  - withCondLine
```
public T withCondLine()
```
    Specified by:
    
    withCondLine in interface HtmlFormattingAppendable
  - withCondIndent
```
public T withCondIndent()
```
    Specified by:
    
    withCondIndent in interface HtmlFormattingAppendable
  - tag
```
public T tag(CharSequence tagName)
```
    Specified by:
    
    tag in interface HtmlFormattingAppendable
  - tagVoid
```
public T tagVoid(CharSequence tagName)
```
    Specified by:
    
    tagVoid in interface HtmlFormattingAppendable
  - getOpenTagText
```
protected String getOpenTagText()
```
  - pushTag
```
protected void pushTag(CharSequence tagName)
```
  - popTag
```
protected void popTag(CharSequence tagName)
```
  - tagOpened
```
protected void tagOpened(CharSequence tagName)
```
  - tagClosed
```
protected void tagClosed(CharSequence tagName)
```
  - getOpenTags
```
public Stack<String> getOpenTags()
```
    Specified by:
    
    getOpenTags in interface HtmlFormattingAppendable
  - getOpenTagsAfterLast
```
public List<String> getOpenTagsAfterLast(CharSequence latestTag)
```
    Specified by:
    
    getOpenTagsAfterLast in interface HtmlFormattingAppendable
  - tag
```
public T tag(CharSequence tagName,
             boolean voidElement)
```
    Specified by:
    
    tag in interface HtmlFormattingAppendable
  - closeTag
```
public T closeTag(CharSequence tagName)
```
    Specified by:
    
    closeTag in interface HtmlFormattingAppendable
  - tag
```
public T tag(CharSequence tagName,
             boolean withIndent,
             boolean withLine,
             Runnable runnable)
```
    Specified by:
    
    tag in interface HtmlFormattingAppendable
  - tagVoidLine
```
public T tagVoidLine(CharSequence tagName)
```
    Specified by:
    
    tagVoidLine in interface HtmlFormattingAppendable
  - tagLine
```
public T tagLine(CharSequence tagName)
```
    Specified by:
    
    tagLine in interface HtmlFormattingAppendable
  - tagLine
```
public T tagLine(CharSequence tagName,
                 boolean voidElement)
```
    Specified by:
    
    tagLine in interface HtmlFormattingAppendable
  - tagLine
```
public T tagLine(CharSequence tagName,
                 Runnable runnable)
```
    Specified by:
    
    tagLine in interface HtmlFormattingAppendable
  - tagIndent
```
public T tagIndent(CharSequence tagName,
                   Runnable runnable)
```
    Specified by:
    
    tagIndent in interface HtmlFormattingAppendable
  - tagLineIndent
```
public T tagLineIndent(CharSequence tagName,
                       Runnable runnable)
```
    Specified by:
    
    tagLineIndent in interface HtmlFormattingAppendable
  - getAppendable
```
public Appendable getAppendable()
```
    Description copied from interface: FormattingAppendable
    
    Get the underlying appendable
    
    Specified by:
    
    getAppendable in interface FormattingAppendable
    
    Returns:
    
    appendable being used for accumulating output
  - getOptions
```
public int getOptions()
```
    Description copied from interface: FormattingAppendable
    
    Get current options
    
    Specified by:
    
    getOptions in interface FormattingAppendable
    
    Returns:
    
    option flags
  - setOptions
```
public T setOptions(int options)
```
    Description copied from interface: FormattingAppendable
    
    Set options on processing text
    
    Specified by:
    
    setOptions in interface FormattingAppendable
    
    Parameters:
    
    options - option flags
    
    Returns:
    
    this
  - getModCount
```
public int getModCount()
```
    Description copied from interface: FormattingAppendable
    
    Get the modification count. Incremented every time there is actual text appended
    
    Specified by:
    
    getModCount in interface FormattingAppendable
    
    Returns:
    
    modification count
  - isPreFormatted
```
public boolean isPreFormatted()
```
    Specified by:
    
    isPreFormatted in interface FormattingAppendable
    
    Returns:
    
    true if in pre-formatted region
  - line
```
public T line()
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    line in interface FormattingAppendable
    
    Returns:
    
    this
  - addLine
```
public T addLine()
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    addLine in interface FormattingAppendable
    
    Returns:
    
    this
  - getPushedPrefixCount
```
public int getPushedPrefixCount()
```
    Description copied from interface: FormattingAppendable
    
    Pop a prefix from the stack and set the current prefix
    
    Specified by:
    
    getPushedPrefixCount in interface FormattingAppendable
    
    Returns:
    
    count of prefixes on stack
  - blankLine
```
public T blankLine()
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    blankLine in interface FormattingAppendable
    
    Returns:
    
    this
  - blankLine
```
public T blankLine(int count)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    blankLine in interface FormattingAppendable
    
    Parameters:
    
    count - number of blank lines to append
    
    Returns:
    
    this
  - blankLineIf
```
public T blankLineIf(boolean predicate)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    blankLineIf in interface FormattingAppendable
    
    Parameters:
    
    predicate - when true append blank line
    
    Returns:
    
    this
  - lineIf
```
public T lineIf(boolean predicate)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    lineIf in interface FormattingAppendable
    
    Parameters:
    
    predicate - if true then new line will be started
    
    Returns:
    
    this
  - indent
```
public T indent()
```
    Description copied from interface: FormattingAppendable
    
    Increase the indent level, will terminate the current line if there is unterminated text
    
    Specified by:
    
    indent in interface FormattingAppendable
    
    Returns:
    
    this
  - willIndent
```
public T willIndent()
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    willIndent in interface FormattingAppendable
    
    Returns:
    
    this
  - unIndent
```
public T unIndent()
```
    Description copied from interface: FormattingAppendable
    
    Decrease the indent level, min level is 0, will terminate the current line if there is unterminated text
    
    Specified by:
    
    unIndent in interface FormattingAppendable
    
    Returns:
    
    this
  - getIOException
```
public IOException getIOException()
```
    Specified by:
    
    getIOException in interface FormattingAppendable
  - append
```
public T append(CharSequence csq)
```
    Specified by:
    
    append in interface FormattingAppendable
    
    Specified by:
    
    append in interface Appendable
  - append
```
public T append(CharSequence csq,
                int start,
                int end)
```
    Specified by:
    
    append in interface FormattingAppendable
    
    Specified by:
    
    append in interface Appendable
  - append
```
public T append(char c)
```
    Specified by:
    
    append in interface FormattingAppendable
    
    Specified by:
    
    append in interface Appendable
  - getText
```
public String getText()
```
    Description copied from interface: FormattingAppendable
    
    get the resulting text from appendable
    
    Specified by:
    
    getText in interface FormattingAppendable
    
    Returns:
    
    appendable toString() result after flushing
  - getText
```
public String getText(int maxBlankLines)
```
    Description copied from interface: FormattingAppendable
    
    get the resulting text from appendable
    
    Specified by:
    
    getText in interface FormattingAppendable
    
    Parameters:
    
    maxBlankLines - maximum blank lines to allow at end, -1 will suppress the last EOL
    
    Returns:
    
    appendable toString() result after flushing
  - flush
```
public T flush()
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    flush in interface FormattingAppendable
    
    Returns:
    
    this
  - flushWhitespaces
```
public T flushWhitespaces()
```
    Description copied from interface: FormattingAppendable
    
    Flush all pending whitespaces
    All preFormatted and conditional regions should be exited prior to this call
    
    Specified by:
    
    flushWhitespaces in interface FormattingAppendable
    
    Returns:
    
    this
  - flush
```
public T flush(int maxBlankLines)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    flush in interface FormattingAppendable
    
    Parameters:
    
    maxBlankLines - maximum blank lines to allow at end, -1 will suppress the last EOL
    
    Returns:
    
    this
  - getIndentPrefix
```
public CharSequence getIndentPrefix()
```
    Description copied from interface: FormattingAppendable
    
    Get prefix appended after a new line character for every indent level
    
    Specified by:
    
    getIndentPrefix in interface FormattingAppendable
    
    Returns:
    
    char sequence of the current indent prefix used for each indent level
  - setIndentPrefix
```
public T setIndentPrefix(CharSequence prefix)
```
    Description copied from interface: FormattingAppendable
    
    Set prefix to append after a new line character for every indent level
    
    Specified by:
    
    setIndentPrefix in interface FormattingAppendable
    
    Parameters:
    
    prefix - prefix characters for new lines appended after this is set
    
    Returns:
    
    this
  - getPrefix
```
public CharSequence getPrefix()
```
    Description copied from interface: FormattingAppendable
    
    Get prefix being applied to all lines, even in pre-formatted sections
    
    Specified by:
    
    getPrefix in interface FormattingAppendable
    
    Returns:
    
    char sequence of the current prefix
  - setPrefix
```
public T setPrefix(CharSequence prefix)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    setPrefix in interface FormattingAppendable
    
    Parameters:
    
    prefix - prefix characters for new lines appended after this is set
    
    Returns:
    
    this
  - addPrefix
```
public T addPrefix(CharSequence prefix)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    addPrefix in interface FormattingAppendable
    
    Parameters:
    
    prefix - prefix characters to add to current prefix for new lines appended after this is set
    
    Returns:
    
    this
  - pushPrefix
```
public T pushPrefix()
```
    Description copied from interface: FormattingAppendable
    
    Save the current prefix on the stack
    
    Specified by:
    
    pushPrefix in interface FormattingAppendable
    
    Returns:
    
    this
  - popPrefix
```
public T popPrefix()
```
    Description copied from interface: FormattingAppendable
    
    Pop a prefix from the stack and set the current prefix
    
    Specified by:
    
    popPrefix in interface FormattingAppendable
    
    Returns:
    
    this
  - addAfterEolRunnable
```
public T addAfterEolRunnable(int atPendingEOL,
                             Runnable runnable)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    addAfterEolRunnable in interface FormattingAppendable
    
    Parameters:
    
    atPendingEOL - pending EOL level
    
    runnable - runnable to run once this EOL is output
    
    Returns:
    
    this
  - getTotalIndentPrefix
```
public CharSequence getTotalIndentPrefix()
```
    Description copied from interface: FormattingAppendable
    
    Get the total indent prefix appended after a new line character, FormattingAppendable.getIndentPrefix() repeated FormattingAppendable.getIndent() times.
    
    Specified by:
    
    getTotalIndentPrefix in interface FormattingAppendable
    
    Returns:
    
    char sequence of the current indent prefix used for each indent level
  - line
```
public T line(Ref<Boolean> lineRef)
```
    Description copied from interface: FormattingAppendable
    
    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
    
    Specified by:
    
    line in interface FormattingAppendable
    
    Parameters:
    
    lineRef - predicate storage will be set to false if conditionalFormatter suppressed a new line
    
    Returns:
    
    this
  - lineIf
```
public T lineIf(Ref<Boolean> lineRef)
```
    Description copied from interface: FormattingAppendable
    
    Add a new line, if lineRef is true, if false means that the new line in FormattingAppendable.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
    
    Specified by:
    
    lineIf in interface FormattingAppendable
    
    Parameters:
    
    lineRef - predicate storage for conditionalFormatter suppressed new line condition
    
    Returns:
    
    this
  - repeat
```
public T repeat(char c,
                int count)
```
    Specified by:
    
    repeat in interface FormattingAppendable
  - repeat
```
public T repeat(CharSequence csq,
                int count)
```
    Specified by:
    
    repeat in interface FormattingAppendable
  - repeat
```
public T repeat(CharSequence csq,
                int start,
                int end,
                int count)
```
    Specified by:
    
    repeat in interface FormattingAppendable
  - isPendingSpace
```
public boolean isPendingSpace()
```
    Description copied from interface: FormattingAppendable
    
    see if there is a pending space
    
    Specified by:
    
    isPendingSpace in interface FormattingAppendable
    
    Returns:
    
    true if space is pending
  - isPendingEOL
```
public boolean isPendingEOL()
```
    Description copied from interface: FormattingAppendable
    
    see if there is a pending space
    
    Specified by:
    
    isPendingEOL in interface FormattingAppendable
    
    Returns:
    
    true if space is pending
  - getPendingEOL
```
public int getPendingEOL()
```
    Description copied from interface: FormattingAppendable
    
    see if there is a pending space
    
    Specified by:
    
    getPendingEOL in interface FormattingAppendable
    
    Returns:
    
    number of pending EOLs
  - getIndent
```
public int getIndent()
```
    Description copied from interface: FormattingAppendable
    
    Get the current indent level + indent offset
    
    Specified by:
    
    getIndent in interface FormattingAppendable
    
    Returns:
    
    indent level
  - setIndentOffset
```
public T setIndentOffset(int indentOffset)
```
    Description copied from interface: FormattingAppendable
    
    Set the current indent level. Not for indenting use. This does not do any calls or validation. Intended use is to set initial indent
    
    Specified by:
    
    setIndentOffset in interface FormattingAppendable
    
    Parameters:
    
    indentOffset - minimum indent that will be used
    
    Returns:
    
    this
  - getLineCount
```
public int getLineCount()
```
    Description copied from interface: FormattingAppendable
    
    Get the number of lines appended, does not include pending: EOLs
    
    Specified by:
    
    getLineCount in interface FormattingAppendable
    
    Returns:
    
    number of lines appended
  - lastOffset
```
public T lastOffset(Ref<Integer> refOffset)
```
    Description copied from interface: FormattingAppendable
    
    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 FormattingAppendable.lastOffset() flush() does not change the value of the reference, only actual character appending.
    
    Specified by:
    
    lastOffset in interface FormattingAppendable
    
    Parameters:
    
    refOffset - reference where to store offset, if no appending was done then value is not changed
    
    Returns:
    
    this
  - lastOffset
```
public int lastOffset()
```
    Description copied from interface: FormattingAppendable
    
    Get offset before the last append, but right after pending: EOLs, spaces or indents were added
    
    Specified by:
    
    lastOffset in interface FormattingAppendable
    
    Returns:
    
    character offset before last append or flush
  - offset
```
public int offset()
```
    Description copied from interface: FormattingAppendable
    
    Get offset after last append, does not include any pending: EOLs, spaces nor indents
    
    Specified by:
    
    offset in interface FormattingAppendable
    
    Returns:
    
    character offset after last append or flush
  - openPreFormatted
```
public T openPreFormatted(boolean keepIndent)
```
    Description copied from interface: FormattingAppendable
    
    Open a pre-formatted section. No monitoring of text is done, all text is output as is while nesting count >0
    
    Specified by:
    
    openPreFormatted in interface FormattingAppendable
    
    Parameters:
    
    keepIndent - if true, if there is pending indent it will be appended before entering pre-format mode
    
    Returns:
    
    this
  - closePreFormatted
```
public T closePreFormatted()
```
    Description copied from interface: FormattingAppendable
    
    Close a pre-formatted section. No monitoring of text is done, all text is output as is while nesting count >0
    
    Specified by:
    
    closePreFormatted in interface FormattingAppendable
    
    Returns:
    
    this
  - openConditional
```
public T openConditional(ConditionalFormatter openFormatter)
```
    Description copied from interface: FormattingAppendable
    
    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.
    
    Specified by:
    
    openConditional in interface FormattingAppendable
    
    Parameters:
    
    openFormatter - to invoke before text is appended
    
    Returns:
    
    this
  - closeConditional
```
public T closeConditional(ConditionalFormatter closeFormatter)
```
    Description copied from interface: FormattingAppendable
    
    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 FormattingAppendable.openConditional(ConditionalFormatter) invoked before appending text. If onText is false then openFormatter passed to FormattingAppendable.openConditional(ConditionalFormatter) was not invoked.
    
    Specified by:
    
    closeConditional in interface FormattingAppendable
    
    Parameters:
    
    closeFormatter - to invoke with parameters informing with what parameters the openFormatter was invoked, if at all
    
    Returns:
    
    this

Class HtmlFormattingAppendableBase<T extends HtmlFormattingAppendableBase>

Field Summary

Fields inherited from interface com.vladsch.flexmark.util.html.FormattingAppendable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HtmlFormattingAppendableBase

HtmlFormattingAppendableBase

HtmlFormattingAppendableBase

HtmlFormattingAppendableBase

Method Detail

isSuppressOpenTagLine

setSuppressOpenTagLine

isSuppressCloseTagLine

setSuppressCloseTagLine

openPre

closePre

inPre

raw

raw

rawPre

rawIndentedPre

text

attr

attr

attr

withAttr

getAttributes

setAttributes

withCondLine

withCondIndent

tag

tagVoid

getOpenTagText

pushTag

popTag

tagOpened

tagClosed

getOpenTags

getOpenTagsAfterLast

tag

closeTag

tag

tagVoidLine

tagLine

tagLine

tagLine

tagIndent

tagLineIndent

getAppendable

getOptions

setOptions

getModCount

isPreFormatted

line

addLine

getPushedPrefixCount

blankLine

blankLine

blankLineIf

lineIf

indent

willIndent

unIndent

getIOException

append

append

append

getText

getText

flush

flushWhitespaces

flush

getIndentPrefix

setIndentPrefix

getPrefix

setPrefix

addPrefix

pushPrefix