Format (BandM metatools API doc)

java.lang.Object
- eu.bandm.tools.format.Format

All Implemented Interfaces:

Formattable, Serializable, Cloneable

Direct Known Subclasses:

Format.Annotated, Format.Compound, Format.Empty, Format.Literal, Format.Markup, Format.Prior, Format.Space, Format.Subst, Format.Variable
```
public abstract class Format
extends Object
implements Cloneable, Serializable, Formattable
```
(1) Base class for all kinds of format objects and (2) their factory class.
(And, at the same time, (3) "containing class" for these sub-classes, which are declared "static". But this is intendend as a mere "lexical" comprehension. Of course this is bad design, esp. because each sub-class inherits itself as an inner class. But the initial author of this package prefers larger, but fewer source files !-)
For a detailed description of concepts see the user documentation.

Format objects have algebraic semantics, they are implemented "imutable". They are created by calls to the static factory methods from this class, and cannot be modified, once created.
Therefore complicated structures can be shared and re-used. Their internal attribute caches are once calculated at creation time and need never be updated.
If modifications are necessary, they are done by cloning, i.e. creating new instances. The subclass Format.Compound provides methods for optimal cloning and clean re-calculating of the internal attributes.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Format.Annotated<A>` Foreseen for data annotations, like the metajava `reference format.`
`static class`	`Format.Append` Prints contained sub-formats horizontally adjacent.
`static class`	`Format.Beneath` Prints its sub-formats vertically aligned one beneath the other.
`static class`	`Format.Beside` Prints all sub-formats directly adjacent, even if they are multi-line.
`static class`	`Format.Block` Prints all sub-formats in the same line as long as possible, and starts a new line for every sub-format which would (probably) exceeded the page width.
`static class`	`Format.BoundVariable` Variable identified by a number, resolved by un-named arguments by counting their positions.
`static class`	`Format.Comment` Arranges all sub-formats with leading asterisks, like a javadoc comment.
`static class`	`Format.Compound` The base class for all formats which combine (= "contain") sub-formats.
`static class`	`Format.Context` Realizes a binding from identifiers to formats, for resolving `Format.FreeVariable`s- bt [__] FIXME DOK FEHLT, NEVER TESTED !?!? NEVER USED !?!?
`static class`	`Format.Empty` Needed eg for case distinctions, when one alternative shall produce nothing.
`static class`	`Format.Forester` Swing tree Generation ONLY for debugging purposes.
`static class`	`Format.FormatPrinter` Central Visitor for formatted printing.
`static class`	`Format.FreeVariable` Variable indetified by a alphanumeric name which can be bound explicitly.
`static class`	`Format.Line` Prints all sub-formats in the same horizional line if this is possible within the page width, otherwise it prints all sub-formats in one vertical line.
`static class`	`Format.Literal` Printed literally to the output.
`static class`	`Format.Markup` Printed literally to the output, but not included in width calculation.
`static class`	`Format.Matcher` Base class for Visitor and Rewriter, Classifier.
`static class`	`Format.MayBreak` Abstract superclass of all compound formats which possibly generate multi-line output when printed.
`protected static class`	`Format.NonFormatPrinter` Prints a format discarding all formatting, producing non-human-readable output.
`static class`	`Format.Prior` This format prints the "parens" format, if it is (directly or indirectly) contained in a Prior Format with a higher priority 'level" (numerically larger priority code).
`static class`	`Format.Rewriter` General purpose Rewriter
`static class`	`Format.Space` Required for horizontal space (of variable size) or for blank lines (always only one at a time!).
`static class`	`Format.Subst` bt [__] FIXME DOK FEHLT, NEVER TESTED !?!? NEVER USED !?!?
`static class`	`Format.Tabular` Realizes ONE line of a table, and prints sub-formats starting in the column indicated by the value of their `indent`.
`static class`	`Format.Variable` Common abstract base class for `Format.FreeVariable` and `Format.BoundVariable`
`static class`	`Format.Visitor` General purpose Visitor

Field Summary

Fields
Modifier and Type	Field and Description
`static Format`	`comma` A public constant reference to a literal format containing a comma.
`static int`	`contentPrefixPrinted`
`static int`	`DEFAULT_WIDTH` Default page width used by `printFormat(PrintWriter)`
`static Format`	`dot` A public constant reference to a literal format containing a dot.
`static Format`	`empty` A constant reference to an empty format.
`protected boolean`	`ground` Reflects that this format does not contain variables.
`protected int`	`indent` The indentation value explicitly assigned by the user.
`static int`	`INDENT_NOT_SET`
`protected boolean`	`invalid` Indicates that all parameters (`minWidth`, `maxWidth`, etc) have to be recalculated.
`protected boolean`	`isAlwaysMultiline` Reflects whether format contains any (non-singleton) `Format.Beneath` formats.
`protected static int`	`LENGTH_PREFIX`
`static Function<String,Format>`	`literal` `Function` re-ification of `literal` factory method.
`protected int`	`maxWidth` Contains maximal width, ie assumes that no single optional line-break is inserted.
`protected int`	`minWidth` Contains minimal width, if not directly at start of line, ie respecting blanks and not including indentation.
`static Pattern`	`pattern_illegal_literal` Characters which are currently not allowed in `Format.Literal`s.
`static Pattern`	`pattern_newline`
`static Pattern`	`pattern_ws`
`static Pattern`	`pattern_wsWithVars`
`static Format`	`space` A constant reference to a space of one(1) column/line.

Fields inherited from interface eu.bandm.tools.format.Formattable
format

Constructor Summary

Constructors
Modifier Constructor and Description

protected Format()

protected Format(int i, int a, boolean mult, boolean ground)

Constructors
Modifier	Constructor and Description
`protected`	`Format()`
`protected`	`Format(int i, int a, boolean mult, boolean ground)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <A> Format`	`annotated(Format format, A annotation)` Creates an `Format.Annotated` format.
`static Format`	`append(Format... f)` Same as `append(Iterable)`
`static Format`	`append(Iterable<? extends Format> f)` Creates an `Format.Append` format.
`static Format`	`apply(Format body, Format... args)`
`static Format`	`apply(Format body, Format.Context c, boolean partial)`
`static Format`	`apply(Format body, Formattable... args)`
`static Format`	`apply(Format body, String name, Format value)`
`Format`	`applyPartial(Formattable... args)`
`Format`	`applyTo(Format... args)` Central and only tested method for resolving variables.
`Format`	`applyTo(Formattable... args)`
`static Format`	`beneath(Format... f)` Same as `beneath(Iterable)`
`static Format`	`beneath(Iterable<? extends Format> f)` Creates an `Format.Beneath` format.
`static Format`	`beside(Format... f)` Same as `beside(Iterable)`
`static Format`	`beside(Iterable<? extends Format> f)` Creates an `Format.Beside` format.
`static Format`	`block(Format... f)` Same as `block(Iterable)`
`static Format`	`block(Iterable<? extends Format> f)` Creates an `Format.Block` format.
`protected boolean`	`calcground()` Calculate whether not containing variables.
`protected int`	`calcmax()` Calculate maximal width.
`protected int`	`calcmin()` Calculate minimal width.
`protected boolean`	`calcmult()` Calculate whether more than one line of output.
`static Format`	`comment(String linePrefix, Format... f)`
`static Format`	`comment(String linePrefix, Iterable<? extends Format> f)`
`static Format`	`comment(@Opt String prefix, String linePrefix, @Opt String suffix, Format... f)` Creates an `Format.Comment` format.
`static Format`	`comment(@Opt String prefix, String linePrefix, @Opt String suffix, Iterable<? extends Format> f)` Creates an `Format.Comment` format.
`abstract String`	`debugPrefix(int n)`
`protected abstract void`	`doprint(Format.FormatPrinter v)` Over-ridden by concrete sub-classes of Format, for performing the adquate print operations.
`Format`	`eval(Format.Context c, boolean partial)`
`Format`	`format()`
`Format`	`indent(int i)` Returns a clone of `this` with the new value of `indent`
`protected boolean`	`indentIsSet()`
`protected void`	`invalidate()` Indicates that all parameters (`minWidth`, `maxWidth`, etc) have to be recalculated.
`protected boolean`	`isSpace()`
`static boolean`	`isValidContentForLiteral(String s)` Returns true iff argument is valid as content of a "literal" format, i.e.
`static Format`	`line(Format... f)` Same as `line(Iterable)`
`static Format`	`line(Iterable<? extends Format> f)` Creates an `Format.Line` format.
`static Format`	`list(Format open, CompoundConstructor outerCombinator, Format delim, CompoundConstructor innerCombinator, Format close, Format... formats)` Same as `list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)`
`static Format`	`list(Format open, CompoundConstructor outerCombinator, Format delim, CompoundConstructor innerCombinator, Format close, Iterable<? extends Format> formats)` Same as `list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)`
`static Format`	`list(Format open, CompoundConstructor outerCombinator, Format delim, CompoundConstructor innerCombinator, Format close, List<Format> formats)` Convenience method, creates a complex format for sequences of `Format`a.
`static Format`	`list(Format open, Format delim, Format close, Format... formats)` Same as `list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)`, where `outerCombinator` defaults to `CompoundConstructor.beside` and `innerCombinator` defaults to `CompoundConstructor.line`
`static Format`	`list(Format open, Format delim, Format close, List<Format> formats)` Same as `list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)`, where `outerCombinator` defaults to `CompoundConstructor.beside` and `innerCombinator` defaults to `CompoundConstructor.line`
`static Format`	`literal(String s)` Create a literal or return an already cached one.
`static void`	`main(String[] args)` Some test method calls.
`protected static Format`	`makeAppend(List<Format> f)`
`protected static Format`	`makeBeneath(List<Format> f)`
`protected static Format`	`makeBeside(List<Format> f)`
`protected static Format`	`makeBlock(List<Format> f)`
`protected static Format`	`makeLine(List<Format> f)`
`protected static Format`	`makeTabular(List<Format> f)`
`static Format`	`markup(String s)` Creates a mark-up format (not occupying any space).
`static Format`	`markupLeft(String s)` Creates a mark-up format (not occupying any space).
`static Format`	`markupRight(String s)` Creates a mark-up format (not occupying any space).
`void`	`printFormat(PrintWriter pw)` Central public function for printing a formst with a default page width..
`void`	`printFormat(PrintWriter pw, int width)` Central public function for printing a formst with the explicitly given page width..
`void`	`printNonFormat(PrintWriter pw)` print a format without any formatting, not intended for human readers.
`static Format`	`prior(int level, Format noparens, Format parens)` Creates a `Format.Prior` format.
`static Format`	`prior(int level, int alternative, Format noparens, Format parens)`
`static Format`	`quoteDTDstyle(Format f)` Creates a literal format which chooses quote symbols not appearing in the data.
`static Format`	`quoteJavaStyle(Format f)` Creates a literal format which quoted doublequotes by escaping them with a backslash.
`static String`	`showLn(Format f, int depth)` creates a debugging representation of a form term, showing the top "depth" levels.
`static String`	`showLn(Format f, int depth, int nesting)`
`static void`	`showSwingTree(Format f, String windowname, boolean isHtml)` Generate a swing tree representation and display it ONLY for debugging.
`static Format`	`space(int i)` Creates a space format.
`static Format`	`subst(Format body, Format... args)`
`static Format`	`subst(Format body, Format.Context c, boolean partial)`
`static Format`	`subst(Format body, String name, Format value)`
`static Format`	`tabular(Format... f)` Same as `tabular(Iterable)`
`static Format`	`tabular(Iterable<? extends Format> f)` Creates an `Format.Tabular` format.
`static Format`	`text(String txt)` Convenience method for translating multi-line text into a complex format hierarchy.
`static Format`	`textWithVars(String txt)`
`Format`	`toFormat(Format... args)` Deprecated.
`String`	`toObjString()` call "toString()" from the "Object" superclass, for debugging only !
`String`	`toString()` Print the format in an unformatted way to a string.
`String`	`toString(int width)` Print the format in a formatted way to a string (include linefeeds!), with the specified maximal column width.
`protected void`	`update()` Just local calculation, assumes that all sub-objects are already valid.
`protected void`	`validate()` Re-calculates all parameters by calling `update()`, iff necessary.
`static Format`	`variable(int index)` Creates a new `Format.BoundVariable` with the given number.
`static Format`	`variable(String name)` Creates a new `Format.FreeVariable` with the given name.

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

Field Detail
- pattern_illegal_literal
```
public static final Pattern pattern_illegal_literal
```
  Characters which are currently not allowed in Format.Literals.
- literal
```
public static final Function<String,Format> literal
```
  Function re-ification of literal factory method.
- comma
```
public static final Format comma
```
  A public constant reference to a literal format containing a comma.
- dot
```
public static final Format dot
```
  A public constant reference to a literal format containing a dot.
- space
```
public static final Format space
```
  A constant reference to a space of one(1) column/line.
- empty
```
public static final Format empty
```
  A constant reference to an empty format.
- pattern_newline
```
public static final Pattern pattern_newline
```
- pattern_ws
```
public static final Pattern pattern_ws
```
- pattern_wsWithVars
```
public static final Pattern pattern_wsWithVars
```
- LENGTH_PREFIX
```
protected static final int LENGTH_PREFIX
```
- INDENT_NOT_SET
```
public static final int INDENT_NOT_SET
```
  See Also:
  
  Constant Field Values
- indent
```
protected int indent
```
  The indentation value explicitly assigned by the user. This will determine the number of spaces the format will begin further to the right then its immediate container, IFF the format is the first in an output line.
- minWidth
```
protected transient int minWidth
```
  Contains minimal width, if not directly at start of line, ie respecting blanks and not including indentation. This is because after starting a new line, no decision on line break is necessary anyhow.
- maxWidth
```
protected transient int maxWidth
```
  Contains maximal width, ie assumes that no single optional line-break is inserted.
- isAlwaysMultiline
```
protected transient boolean isAlwaysMultiline
```
  Reflects whether format contains any (non-singleton) Format.Beneath formats. Needed for "line" and "block", which propagate line breaks contained therein to their own layout.
- ground
```
protected transient boolean ground
```
  Reflects that this format does not contain variables.
- invalid
```
protected boolean invalid
```
  Indicates that all parameters (minWidth, maxWidth, etc) have to be recalculated.
- DEFAULT_WIDTH
```
public static final int DEFAULT_WIDTH
```
  Default page width used by printFormat(PrintWriter)
  
  See Also:
  
  Constant Field Values
- contentPrefixPrinted
```
public static final int contentPrefixPrinted
```
  See Also:
  
  Constant Field Values

Constructor Detail

Format

protected Format(int i,
                 int a,
                 boolean mult,
                 boolean ground)

Format
```
protected Format()
```

Method Detail

format
```
public final Format format()
```
Specified by:

format in interface Formattable

isValidContentForLiteral
```
public static boolean isValidContentForLiteral(String s)
```
Returns true iff argument is valid as content of a "literal" format, i.e. does neither contain tab nor newline characters.

literal
```
public static Format literal(String s)
```
Create a literal or return an already cached one.

Throws:

IllegalArgumentException - in case the string argument contains tabs or newline pattern_illegal_literal.

markup
```
public static Format markup(String s)
```
Creates a mark-up format (not occupying any space).

markupRight
```
public static Format markupRight(String s)
```
Creates a mark-up format (not occupying any space).

markupLeft
```
public static Format markupLeft(String s)
```
Creates a mark-up format (not occupying any space).

space
```
public static Format space(int i)
```
Creates a space format.

prior

public static Format prior(int level,
                           Format noparens,
                           Format parens)

Creates a Format.Prior format.

prior

public static Format prior(int level,
                           int alternative,
                           Format noparens,
                           Format parens)

makeAppend

protected static Format makeAppend(List<Format> f)

makeBlock

protected static Format makeBlock(List<Format> f)

makeLine

protected static Format makeLine(List<Format> f)

makeBeside

protected static Format makeBeside(List<Format> f)

makeBeneath

protected static Format makeBeneath(List<Format> f)

makeTabular

protected static Format makeTabular(List<Format> f)

append
```
public static Format append(Iterable<? extends Format> f)
```
Creates an Format.Append format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

block
```
public static Format block(Iterable<? extends Format> f)
```
Creates an Format.Block format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

line
```
public static Format line(Iterable<? extends Format> f)
```
Creates an Format.Line format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

beside
```
public static Format beside(Iterable<? extends Format> f)
```
Creates an Format.Beside format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

beneath
```
public static Format beneath(Iterable<? extends Format> f)
```
Creates an Format.Beneath format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

tabular
```
public static Format tabular(Iterable<? extends Format> f)
```
Creates an Format.Tabular format.
In case of zero(0) arguments returns an Format.Empty format instead.
In case of only one (1) argument returns this argument.

comment

public static Format comment(@Opt
                             @Opt String prefix,
                             String linePrefix,
                             @Opt
                             @Opt String suffix,
                             Iterable<? extends Format> f)

Creates an Format.Comment format.

comment

public static Format comment(@Opt
                             @Opt String prefix,
                             String linePrefix,
                             @Opt
                             @Opt String suffix,
                             Format... f)

Creates an Format.Comment format.

comment

public static Format comment(String linePrefix,
                             Iterable<? extends Format> f)

comment

public static Format comment(String linePrefix,
                             Format... f)

append

public static Format append(Format... f)

Same as append(Iterable)

block

public static Format block(Format... f)

Same as block(Iterable)

line

public static Format line(Format... f)

Same as line(Iterable)

beside

public static Format beside(Format... f)

Same as beside(Iterable)

beneath

public static Format beneath(Format... f)

Same as beneath(Iterable)

tabular

public static Format tabular(Format... f)

Same as tabular(Iterable)

indent
```
public Format indent(int i)
```
Returns a clone of this with the new value of indent

annotated

public static <A> Format annotated(Format format,
                                   A annotation)

Creates an Format.Annotated format.

variable
```
public static Format variable(String name)
```
Creates a new Format.FreeVariable with the given name.

variable
```
public static Format variable(int index)
```
Creates a new Format.BoundVariable with the given number.

subst

public static Format subst(Format body,
                           Format.Context c,
                           boolean partial)

subst

public static Format subst(Format body,
                           Format... args)

subst

public static Format subst(Format body,
                           String name,
                           Format value)

apply

public static Format apply(Format body,
                           Format.Context c,
                           boolean partial)

apply

public static Format apply(Format body,
                           Format... args)

apply

public static Format apply(Format body,
                           Formattable... args)

apply

public static Format apply(Format body,
                           String name,
                           Format value)

applyTo
```
public final Format applyTo(Format... args)
```
Central and only tested method for resolving variables. It resolves only Format.BoundVariables, ie variables identified by numbers. This is the only one of the many methods of dealing with variables which is ubiquituously applied in meta-tools. It requires that the mapping is total, ie that at least as much parameters are supplied as the highest number of all contained variables plus one (+1).

applyTo

public final Format applyTo(Formattable... args)

applyPartial

public final Format applyPartial(Formattable... args)

toFormat

@Deprecated
public Format toFormat(Format... args)

Deprecated.

quoteDTDstyle
```
public static Format quoteDTDstyle(Format f)
```
Creates a literal format which chooses quote symbols not appearing in the data.
If the data does not contain single quotes then the result is an Format.Append with single quotes as first and last character.
Otherwise, if data does not contain double quotes, then do the same with double quotes.
Otherwise replace single quotes with a character entity and use single quotes.

quoteJavaStyle
```
public static Format quoteJavaStyle(Format f)
```
Creates a literal format which quoted doublequotes by escaping them with a backslash. (This is similar to metajave FIXME, but is restricted).

text
```
public static Format text(String txt)
```
Convenience method for translating multi-line text into a complex format hierarchy.
The result will have the structure
```
  Beneath
  |  
  |  Block 
  |  |  Literal
  |  |  Space
  |  |  Literal
  |  |  Space
  |  |  Literal
  |  Space
  |  Block 
  |  |  Literal
  |  |  Space
  |  |  Literal
```
The limits of blocks will be given by hard "newlines" contained in the text.
Whitespace will be translated into Space and non-whitespace into Literal
Whitespace at the beginning of a line (following a hard newline) will be translated into indentation.
Empty lines (two consecutive newline characters) results to space on the upper level, under the Beneath combinator.

textWithVars

public static Format textWithVars(String txt)

list

public static Format list(Format open,
                          CompoundConstructor outerCombinator,
                          Format delim,
                          CompoundConstructor innerCombinator,
                          Format close,
                          Iterable<? extends Format> formats)

Same as list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)

list

public static Format list(Format open,
                          Format delim,
                          Format close,
                          Format... formats)

Same as list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List), where outerCombinator defaults to CompoundConstructor.beside and innerCombinator defaults to CompoundConstructor.line

list

public static Format list(Format open,
                          Format delim,
                          Format close,
                          List<Format> formats)

list

public static Format list(Format open,
                          CompoundConstructor outerCombinator,
                          Format delim,
                          CompoundConstructor innerCombinator,
                          Format close,
                          Format... formats)

Same as list(Format,CompoundConstructor,Format,CompoundConstructor,Format,List)

list

public static Format list(Format open,
                          CompoundConstructor outerCombinator,
                          Format delim,
                          CompoundConstructor innerCombinator,
                          Format close,
                          List<Format> formats)

Convenience method, creates a complex format for sequences of Formata. The structure which is created is determinded to

   outer combinator
   |  |  |
   |  |  close
   |  | 
   |  inner comb.-----+---    .... ---+
   |  |               |               |
   |  Append          Append          f[last]
   |  |    |          |    |        
   |  f[0] delim      f[1] delim
   |
   open

Parameters:: open - the format at the very left of the result, like an open parenthesis; outerCombinator - how to combine open, the inner list, and close; delim - the format to separate the elements of the list, like a comma; innerCombinator - how to combine the elements of the inner list; close - the format at the very right of the result, like a closing parenthesis; formats - the sequence of inner elements.

showLn
```
public static String showLn(Format f,
                            int depth)
```
creates a debugging representation of a form term, showing the top "depth" levels.

showLn

public static String showLn(Format f,
                            int depth,
                            int nesting)

debugPrefix

public abstract String debugPrefix(int n)

indentIsSet
```
protected boolean indentIsSet()
```

isSpace
```
protected boolean isSpace()
```

invalidate
```
protected final void invalidate()
```
Indicates that all parameters (minWidth, maxWidth, etc) have to be recalculated.

validate
```
protected void validate()
```
Re-calculates all parameters by calling update(), iff necessary. Is over-ridden by Format.Compound for prior descending to sub-formats.

update
```
protected void update()
```
Just local calculation, assumes that all sub-objects are already valid. This method Is not overridden (only by Format.Compound, testing not being a temporary copy). Instead, the differente "calc<..>" methods are overridden individually.

calcmin
```
protected int calcmin()
```
Calculate minimal width. Is abstract on this level, but over-ridden by sub-classes.

calcmax
```
protected int calcmax()
```
Calculate maximal width. Is abstract on this level, but over-ridden by sub-classes.

calcmult
```
protected boolean calcmult()
```
Calculate whether more than one line of output. Is abstract on this level, but over-ridden by sub-classes.

calcground
```
protected boolean calcground()
```
Calculate whether not containing variables. Is abstract on this level, but over-ridden by sub-classes.

eval

public Format eval(Format.Context c,
                   boolean partial)

doprint
```
protected abstract void doprint(Format.FormatPrinter v)
```
Over-ridden by concrete sub-classes of Format, for performing the adquate print operations.

printFormat
```
public void printFormat(PrintWriter pw)
```
Central public function for printing a formst with a default page width..

printFormat
```
public void printFormat(PrintWriter pw,
                        int width)
```
Central public function for printing a formst with the explicitly given page width..

printNonFormat
```
public void printNonFormat(PrintWriter pw)
```
print a format without any formatting, not intended for human readers.

toString
```
public String toString()
```
Print the format in an unformatted way to a string.

Overrides:

toString in class Object

toString
```
public String toString(int width)
```
Print the format in a formatted way to a string (include linefeeds!), with the specified maximal column width.

toObjString
```
public String toObjString()
```
call "toString()" from the "Object" superclass, for debugging only !

showSwingTree
```
public static void showSwingTree(Format f,
                                 String windowname,
                                 boolean isHtml)
```
Generate a swing tree representation and display it ONLY for debugging.
copied from umod/runtime/SwingBrowser.java:

Parameters:

f - the Format to display

windowname - the Title of the window

isHtml - if tree labels use html features

main

public static void main(String[] args)

Some test method calls.

Class Format

Nested Class Summary

Field Summary

Fields inherited from interface eu.bandm.tools.format.Formattable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

pattern_illegal_literal

literal

comma

dot

space

empty

pattern_newline

pattern_ws

pattern_wsWithVars

LENGTH_PREFIX

INDENT_NOT_SET

indent

minWidth

maxWidth

isAlwaysMultiline

ground

invalid

DEFAULT_WIDTH

contentPrefixPrinted

Constructor Detail

Format

Format

Method Detail

format

isValidContentForLiteral

literal

markup

markupRight

markupLeft

space

prior

prior

makeAppend

makeBlock

makeLine

makeBeside

makeBeneath

makeTabular

append

block

line

beside

beneath

tabular

comment

comment

comment

comment

append

block

line

beside

beneath

tabular

indent

annotated

variable

variable

subst

subst

subst

apply

apply

apply

apply

applyTo

applyTo

applyPartial

toFormat

quoteDTDstyle

quoteJavaStyle

text