/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.sis.io.wkt;

import java.util.Map;
import java.util.Set;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Locale;
import java.util.Date;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.FieldPosition;
import java.io.IOException;
import java.lang.reflect.Array;
import java.math.RoundingMode;
import javax.measure.Unit;
import javax.measure.Quantity;

import org.opengis.util.CodeList;
import org.opengis.util.InternationalString;
import org.opengis.metadata.Identifier;
import org.opengis.metadata.citation.Citation;
import org.opengis.metadata.extent.Extent;
import org.opengis.metadata.extent.VerticalExtent;
import org.opengis.metadata.extent.TemporalExtent;
import org.opengis.metadata.extent.GeographicBoundingBox;
import org.opengis.parameter.GeneralParameterDescriptor;
import org.opengis.parameter.GeneralParameterValue;
import org.opengis.referencing.IdentifiedObject;
import org.opengis.referencing.ReferenceIdentifier;
import org.opengis.referencing.ReferenceSystem;
import org.opengis.referencing.datum.Datum;
import org.opengis.referencing.crs.CompoundCRS;
import org.opengis.referencing.cs.CoordinateSystemAxis;
import org.opengis.referencing.operation.OperationMethod;
import org.opengis.referencing.operation.CoordinateOperation;
import org.opengis.referencing.operation.ConcatenatedOperation;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.geometry.coordinate.Position;
import org.opengis.geometry.Envelope;

import org.apache.sis.measure.Units;
import org.apache.sis.math.DecimalFunctions;
import org.apache.sis.util.iso.Types;
import org.apache.sis.util.Classes;
import org.apache.sis.util.Numbers;
import org.apache.sis.util.Localized;
import org.apache.sis.util.Exceptions;
import org.apache.sis.util.Characters;
import org.apache.sis.util.CharSequences;
import org.apache.sis.util.ArgumentChecks;
import org.apache.sis.util.resources.Errors;
import org.apache.sis.util.resources.Vocabulary;
import org.apache.sis.util.collection.IntegerList;
import org.apache.sis.metadata.iso.citation.Citations;
import org.apache.sis.internal.util.X364;
import org.apache.sis.internal.util.Numerics;
import org.apache.sis.internal.util.Constants;
import org.apache.sis.internal.util.StandardDateFormat;
import org.apache.sis.internal.simple.SimpleExtent;
import org.apache.sis.internal.metadata.Resources;
import org.apache.sis.internal.referencing.WKTKeywords;
import org.apache.sis.internal.referencing.WKTUtilities;
import org.apache.sis.referencing.AbstractIdentifiedObject;
import org.apache.sis.geometry.AbstractDirectPosition;
import org.apache.sis.geometry.AbstractEnvelope;
import org.apache.sis.measure.UnitFormat;
import org.apache.sis.measure.Range;
import org.apache.sis.measure.MeasurementRange;
import org.apache.sis.referencing.ImmutableIdentifier;
import org.apache.sis.metadata.iso.extent.Extents;
import org.apache.sis.math.Vector;


/**
 * Provides support methods for formatting a <cite>Well Known Text</cite> (WKT).
 *
 * <p>{@code Formatter} instances are created by {@link WKTFormat} and given to the
 * {@link FormattableObject#formatTo(Formatter)} method of the object to format.
 * {@code Formatter} provides the following services:</p>
 *
 * <ul>
 *   <li>A series of {@code append(…)} methods to be invoked by the {@code formatTo(Formatter)} implementations.</li>
 *   <li>Contextual information. In particular, the {@linkplain #toContextualUnit(Unit) contextual units} depend on
 *       the {@linkplain #getEnclosingElement(int) enclosing WKT element}.</li>
 *   <li>A flag for declaring the object unformattable.</li>
 * </ul>
 *
 * @author  Martin Desruisseaux (IRD, Geomatys)
 * @version 1.0
 *
 * @see <a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html">WKT 2 specification</a>
 * @see <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/doc-files/WKT.html">Legacy WKT 1</a>
 *
 * @since 0.4
 * @module
 */
public class Formatter implements Localized {
    /**
     * Accuracy of geographic bounding boxes, in number of fraction digits.
     * We use the accuracy recommended by ISO 19162.
     */
    static final int BBOX_ACCURACY = 2;

    /**
     * Maximal accuracy of vertical extents, in number of fraction digits.
     * The value used here is arbitrary and may change in any future SIS version.
     */
    private static final int VERTICAL_ACCURACY = 9;

    /**
     * The value of {@code X364.FOREGROUND_DEFAULT.sequence()}, hard-coded for avoiding
     * {@link org.apache.sis.internal.util.X364} class loading.
     */
    static final String FOREGROUND_DEFAULT = "\u001B[39m";

    /**
     * The value of {@code X364.BACKGROUND_DEFAULT.sequence()}, hard-coded for avoiding
     * {@link org.apache.sis.internal.util.X364} class loading.
     */
    static final String BACKGROUND_DEFAULT = "\u001B[49m";

    /**
     * The locale for the localization of international strings.
     * This is not the same than {@link Symbols#getLocale()}.
     */
    private final Locale locale;

    /**
     * The symbols to use for this formatter.
     *
     * @see WKTFormat#getSymbols()
     * @see WKTFormat#setSymbols(Symbols)
     */
    private final Symbols symbols;

    /**
     * The value of {@link Symbols#getSeparator()} without trailing spaces, followed by the system line separator.
     * Computed by {@link Symbols#separatorNewLine()} and stored for reuse.
     */
    private final String separatorNewLine;

    /**
     * The colors to use for this formatter, or {@code null} for no syntax coloring.
     * If non-null, the terminal must be ANSI X3.64 compatible.
     * The default value is {@code null}.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private Colors colors;

    /**
     * The preferred convention for objects or parameter names.
     * This field should never be {@code null}.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private Convention convention;

    /**
     * The preferred authority for objects or parameter names.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private Citation authority;

    /**
     * {@link Transliterator#IDENTITY} for preserving non-ASCII characters. The default value is
     * {@link Transliterator#DEFAULT}, which causes replacements like "é" → "e" in all elements
     * except {@code REMARKS["…"]}. May also be a user-supplied transliterator.
     *
     * @see #getTransliterator()
     */
    Transliterator transliterator;

    /**
     * {@code true} if this {@code Formatter} should verify the validity of characters in quoted texts.
     * ISO 19162 restricts quoted texts to ASCII characters with addition of degree symbol (°).
     */
    boolean verifyCharacterValidity = true;

    /**
     * The enclosing WKT element being formatted.
     *
     * @see #getEnclosingElement(int)
     */
    private final List<FormattableObject> enclosingElements = new ArrayList<>();

    /**
     * The contextual units for writing lengths, angles or other type of measurements.
     * A unit not present in this map means that the "natural" unit of the WKT element shall be used.
     * This value is set for example by {@code "GEOGCS"}, which force its enclosing {@code "PRIMEM"}
     * to take the same units than itself.
     *
     * @see #addContextualUnit(Unit)
     * @see #toContextualUnit(Unit)
     */
    private final Map<Unit<?>, Unit<?>> units = new HashMap<>(4);

    /**
     * A bits mask of elements which defined a contextual units.
     * The rightmost bit is for the current element. The bit before the rightmost
     * is for the parent of current element, etc.
     *
     * @see #hasContextualUnit(int)
     */
    private long hasContextualUnit;

    /**
     * The object to use for formatting numbers.
     */
    private final NumberFormat numberFormat;

    /**
     * The object to use for formatting dates.
     */
    private final DateFormat dateFormat;

    /**
     * The object to use for formatting unit symbols.
     */
    private final UnitFormat unitFormat;

    /**
     * Dummy field position.
     */
    private final FieldPosition dummy = new FieldPosition(0);

    /**
     * The buffer in which to format. Consider this field as final. The only method to change
     * (indirectly) the value of this field is {@link WKTFormat#format(Object, Appendable)}.
     *
     * @see #setBuffer(StringBuffer)
     */
    private StringBuffer buffer;

    /**
     * Index of the first character in the buffer where the element content will be formatted.
     * This is set after the opening bracket and is used for determining if a separator needs
     * to be appended.
     *
     * @see #setBuffer(StringBuffer)
     */
    private int elementStart;

    /**
     * {@code 1} if keywords shall be converted to upper cases, or {@code -1} for lower cases.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private byte toUpperCase;

    /**
     * {@code -1} for short keywords, {@code +1} for long keywords or 0 for the default.
     */
    private byte longKeywords;

    /**
     * Maximum number of elements to show in lists, or {@link Integer#MAX_VALUE} if unlimited.
     * If a list is longer than this length, only the first and the last elements will be shown.
     * This limit applies in particular to {@link MathTransform} parameter values of {@code double[]}
     * type, since those parameters may be large interpolation tables.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private int listSizeLimit;

    /**
     * Incremented when {@link #setColor(ElementKind)} is invoked, and decremented when {@link #resetColor()}
     * is invoked. Used in order to prevent child elements to overwrite the colors decided by enclosing elements.
     */
    private int colorApplied;

    /**
     * The amount of spaces to use in indentation, or {@value org.apache.sis.io.wkt.WKTFormat#SINGLE_LINE}
     * if indentation is disabled.
     *
     * @see #configure(Convention, Citation, Colors, byte, byte, byte, int)
     */
    private byte indentation;

    /**
     * The amount of space to write on the left side of each line. This amount is increased
     * by {@code indentation} every time a {@link FormattableObject} is appended in a new
     * indentation level.
     */
    private int margin;

    /**
     * Indices where to insert additional margin, or {@code null} if none. The margin to insert will be
     * the the width of the keyword (e.g. {@code "BOX"}), which is usually unknown to {@code Formatter}
     * until {@link FormattableObject} finished to write the element. This field is usually {@code null},
     * unless formatting geometries.
     */
    private IntegerList keywordSpaceAt;

    /**
     * {@code true} if a new line were requested during the execution of {@link #append(FormattableObject)}.
     * This is used to determine if the next {@code UNIT} and {@code ID} elements shall appear on a new line.
     */
    private boolean requestNewLine;

    /**
     * {@code true} if we are in the process of formatting the optional complementary attributes.
     * Those attributes are {@code SCOPE}, {@code AREA}, {@code BBOX}, {@code VERTICALEXTENT}, {@code TIMEEXTENT},
     * {@code ID} (previously known as {@code AUTHORITY}) and {@code REMARKS}, and have a special treatment: they
     * are written by {@link #append(FormattableObject)} after the {@code formatTo(Formatter)} method returned.
     *
     * @see #appendComplement(IdentifiedObject, FormattableObject, FormattableObject)
     */
    private boolean isComplement;

    /**
     * {@code true} if the last formatted element was invalid WKT and shall be highlighted with syntactic coloration.
     * This field has no effect if {@link #colors} is null. This field is reset to {@code false} after the invalid
     * part has been processed by {@link #append(FormattableObject)}, in order to highlight only the first erroneous
     * element without clearing the {@link #warnings} value.
     */
    private boolean highlightError;

    /**
     * The warnings that occurred during WKT formatting, or {@code null} if none.
     *
     * @see #isInvalidWKT()
     * @see #getWarnings()
     */
    private Warnings warnings;

    /**
     * Creates a new formatter instance with the default configuration.
     */
    public Formatter() {
        this(Convention.DEFAULT, Symbols.getDefault(), Constants.DEFAULT_INDENTATION);
    }

    /**
     * Creates a new formatter instance with the specified convention, symbols and indentation.
     *
     * @param  convention   the convention to use.
     * @param  symbols      the symbols.
     * @param  indentation  the amount of spaces to use in indentation for WKT formatting,
     *                      or {@link WKTFormat#SINGLE_LINE} for formatting the whole WKT on a single line.
     */
    public Formatter(final Convention convention, final Symbols symbols, final int indentation) {
        ArgumentChecks.ensureNonNull("convention",  convention);
        ArgumentChecks.ensureNonNull("symbols",     symbols);
        ArgumentChecks.ensureBetween("indentation", WKTFormat.SINGLE_LINE, Byte.MAX_VALUE, indentation);
        this.locale           = Locale.getDefault(Locale.Category.DISPLAY);
        this.convention       = convention;
        this.authority        = convention.getNameAuthority();
        this.symbols          = symbols.immutable();
        this.separatorNewLine = this.symbols.separatorNewLine();
        this.indentation      = (byte) indentation;
        this.numberFormat     = symbols.createNumberFormat();
        this.dateFormat       = new StandardDateFormat(symbols.getLocale());
        this.unitFormat       = new UnitFormat(symbols.getLocale());
        this.buffer           = new StringBuffer();
        unitFormat.setStyle(UnitFormat.Style.NAME);
        if (convention.usesCommonUnits) {
            unitFormat.setLocale(Locale.US);
        }
    }

    /**
     * Constructor for private use by {@link WKTFormat} only. This allows to use the number format
     * created by {@link WKTFormat#createFormat(Class)}, which may be overridden by the user.
     */
    Formatter(final Locale locale, final Symbols symbols, final NumberFormat numberFormat,
            final DateFormat dateFormat, final UnitFormat unitFormat)
    {
        this.locale           = locale;
        this.convention       = Convention.DEFAULT;
        this.authority        = Convention.DEFAULT.getNameAuthority();
        this.symbols          = symbols;
        this.separatorNewLine = symbols.separatorNewLine();
        this.indentation      = Constants.DEFAULT_INDENTATION;
        this.numberFormat     = numberFormat;                      // No clone needed.
        this.dateFormat       = dateFormat;
        this.unitFormat       = unitFormat;
        // Do not set the buffer. It will be set by WKTFormat.format(…).
    }

    /**
     * Sets the destination buffer. Used by {@link WKTFormat#format(Object, Appendable)} only.
     */
    final void setBuffer(final StringBuffer buffer) {
        this.buffer = buffer;
        elementStart = (buffer != null) ? buffer.length() : 0;
    }

    /**
     * Sets the convention, authority, colors and indentation to use for formatting WKT elements.
     * This method does not validate the argument — validation must be done by the caller.
     *
     * @param  convention    the convention, or {@code null} for the default value.
     * @param  authority     the authority, or {@code null} for inferring it from the convention.
     * @param  colors        the syntax coloring, or {@code null} if none.
     * @param  toUpperCase   whether keywords shall be converted to upper cases.
     * @param  longKeywords  {@code -1} for short keywords, {@code +1} for long keywords or 0 for the default.
     * @param  indentation   the amount of spaces to use in indentation for WKT formatting, or {@link WKTFormat#SINGLE_LINE}.
     * @param  listSizeLimit maximum number of elements to show in lists, or {@link Integer#MAX_VALUE} if unlimited.
     */
    final void configure(Convention convention, final Citation authority, final Colors colors,
            final byte toUpperCase, final byte longKeywords, final byte indentation, final int listSizeLimit)
    {
        this.convention     = convention;
        this.authority      = (authority != null) ? authority : convention.getNameAuthority();
        this.colors         = colors;
        this.toUpperCase    = toUpperCase;
        this.longKeywords   = longKeywords;
        this.indentation    = indentation;
        this.listSizeLimit  = listSizeLimit;
        this.transliterator = (convention == Convention.INTERNAL) ? Transliterator.IDENTITY : Transliterator.DEFAULT;
        unitFormat.setLocale(convention.usesCommonUnits ? Locale.US : Locale.ROOT);
    }

    /**
     * Returns the convention to use for formatting the WKT. The default is {@link Convention#WKT2}.
     *
     * @return the convention (never {@code null}).
     *
     * @see WKTFormat#setConvention(Convention)
     * @see FormattableObject#toString(Convention)
     */
    public final Convention getConvention() {
        return convention;
    }

    /**
     * Returns a mapper between Java character sequences and the characters to write in WKT.
     * The intent is to specify how to write characters that are not allowed in WKT strings
     * according ISO 19162 specification. Return values can be:
     *
     * <ul>
     *   <li>{@link Transliterator#DEFAULT} for performing replacements like "é" → "e"
     *       in all WKT elements except {@code REMARKS["…"]}.</li>
     *   <li>{@link Transliterator#IDENTITY} for preserving non-ASCII characters.</li>
     *   <li>Any other user-supplied mapping.</li>
     * </ul>
     *
     * @return the mapper between Java character sequences and the characters to write in WKT.
     *
     * @see WKTFormat#setTransliterator(Transliterator)
     *
     * @since 0.6
     */
    public final Transliterator getTransliterator() {
        return transliterator;
    }

    /**
     * Returns the preferred authority for choosing the projection and parameter names.
     *
     * <p>The preferred authority can be set by the {@link WKTFormat#setNameAuthority(Citation)} method.
     * This is not necessarily the authority who created the object to format.</p>
     *
     * <div class="note"><b>Example:</b>
     * The EPSG name of the {@code EPSG:6326} datum is <cite>"World Geodetic System 1984"</cite>.
     * However if the preferred authority is OGC, then the formatted datum name will rather look like
     * <cite>"WGS84"</cite> (the exact string depends on the object aliases).</div>
     *
     * @return the authority for projection and parameter names.
     *
     * @see WKTFormat#getNameAuthority()
     * @see org.apache.sis.referencing.IdentifiedObjects#getName(IdentifiedObject, Citation)
     */
    public final Citation getNameAuthority() {
        return authority;
    }

    /**
     * Returns the locale to use for localizing {@link InternationalString} instances.
     * This is <em>not</em> the locale for formatting dates and numbers.
     *
     * @return the locale to use for localizing international strings.
     */
    @Override
    public final Locale getLocale() {
        return locale;
    }

    /**
     * Appends in the {@linkplain #buffer} the ANSI escape sequence for the given kind of element.
     * This method does nothing unless syntax coloring has been explicitly enabled.
     */
    private void setColor(final ElementKind type) {
        if (colors != null) {
            if (colorApplied == 0) {
                final String color = colors.getAnsiSequence(type);
                if (color == null) {
                    // Do not increment 'colorApplied' for giving a chance to children to apply their colors.
                    return;
                }
                final boolean isStart = (buffer.length() == elementStart);
                buffer.append(color);
                if (isStart) {
                    elementStart = buffer.length();
                }
            }
            colorApplied++;
        }
    }

    /**
     * Appends in the {@linkplain #buffer} the ANSI escape sequence for reseting the color to the default.
     * This method does nothing unless syntax coloring has been explicitly enabled.
     */
    private void resetColor() {
        if (colors != null && --colorApplied <= 0) {
            colorApplied = 0;
            buffer.append(FOREGROUND_DEFAULT);
        }
    }

    /**
     * Request a line separator before the next element to format. Invoking this method before any
     * {@code append(…)} method call will cause the next element to appear on the next line.
     *
     * <p>This method has no effect in any of the following cases:</p>
     * <ul>
     *   <li>This method has already been invoked before the next {@code append(…)}.</li>
     *   <li>The indentation is {@link WKTFormat#SINGLE_LINE}.</li>
     * </ul>
     */
    public void newLine() {
        if (indentation > WKTFormat.SINGLE_LINE) {
            requestNewLine = true;
        }
    }

    /**
     * Increases or decreases the indentation. A value of {@code +1} increases
     * the indentation by the amount of spaces specified at construction time,
     * and a value of {@code -1} reduces it by the same amount.
     *
     * @param  amount  +1 for increasing the indentation, or -1 for decreasing it, or 0 for no-op.
     */
    public void indent(final int amount) {
        margin = Math.max(0, margin + indentation*amount);
    }

    /**
     * Selects a short or long keyword depending on the {@link KeywordStyle} value.
     * This method can be used by {@link FormattableObject#formatTo(Formatter)}
     * implementations for choosing the return value.
     *
     * @param  shortKeyword  the keyword to return if the style is {@link KeywordStyle#SHORT}.
     * @param  longKeyword   the keyword to return if the style is {@link KeywordStyle#LONG}.
     * @return the short or long keyword depending on the keyword style setting.
     *
     * @see WKTFormat#setKeywordStyle(KeywordStyle)
     *
     * @since 0.6
     */
    public String shortOrLong(final String shortKeyword, final String longKeyword) {
        return (longKeywords != 0
                ? longKeywords < 0              // If keyword style was explicitly specified, use the setting.
                : convention.toUpperCase)       // Otherwise use the default value determined by the convention.
               ? shortKeyword : longKeyword;
    }

    /**
     * Conditionally appends a separator to the {@linkplain #buffer}, if needed.
     * This method does nothing if there is currently no element at the buffer end.
     */
    private void appendSeparator() {
        if (buffer.length() != elementStart) {
            if (requestNewLine) {
                buffer.append(separatorNewLine).append(CharSequences.spaces(margin));
            } else {
                buffer.append(symbols.getSeparator());
            }
        } else if (requestNewLine) {
            buffer.append(System.lineSeparator()).append(CharSequences.spaces(margin));
        }
        requestNewLine = false;
    }

    /**
     * Appends a separator if needed, then opens a new element.
     *
     * @param  newLine  {@code true} for invoking {@link #newLine()} first.
     * @param  keyword  the element keyword (e.g. {@code "DATUM"}, {@code "AXIS"}, <i>etc</i>).
     */
    private void openElement(final boolean newLine, String keyword) {
        if (newLine && buffer.length() != elementStart) {
            newLine();
        }
        appendSeparator();
        if (toUpperCase != 0) {
            final Locale locale = symbols.getLocale();
            keyword = (toUpperCase >= 0) ? keyword.toUpperCase(locale) : keyword.toLowerCase(locale);
        }
        elementStart = buffer.append(keyword).appendCodePoint(symbols.getOpeningBracket(0)).length();
    }

    /**
     * Closes the element opened by {@link #openElement(boolean, String)}.
     *
     * @param  newLine  {@code true} for invoking {@link #newLine()} last.
     */
    private void closeElement(final boolean newLine) {
        buffer.appendCodePoint(symbols.getClosingBracket(0));
        if (newLine) {
            newLine();
        }
    }

    /**
     * Appends the given {@code FormattableObject}.
     * This method performs the following steps:
     *
     * <ul>
     *   <li>Invoke <code>object.{@linkplain FormattableObject#formatTo(Formatter) formatTo}(this)</code>.</li>
     *   <li>Prepend the keyword returned by the above method call (e.g. {@code "GEOCS"}).</li>
     *   <li>If the given object is an instance of {@link IdentifiedObject}, then append complementary information:</li>
     * </ul>
     *
     * <blockquote><table class="sis">
     *   <caption>Complementary WKT elements</caption>
     *   <tr><th>WKT 2 element</th><th>WKT 1 element</th><th>For types</th></tr>
     *   <tr><td>{@code Anchor[…]}</td>        <td></td> <td>{@link Datum}</td></tr>
     *   <tr><td>{@code Scope[…]}</td>         <td></td> <td>{@link ReferenceSystem}, {@link Datum}, {@link CoordinateOperation}</td></tr>
     *   <tr><td>{@code Area[…]}</td>          <td></td> <td>{@link ReferenceSystem}, {@link Datum}, {@link CoordinateOperation}</td></tr>
     *   <tr><td>{@code BBox[…]}</td>          <td></td> <td>{@link ReferenceSystem}, {@link Datum}, {@link CoordinateOperation}</td></tr>
     *   <tr><td>{@code VerticalExtent[…]}</td><td></td> <td>{@link ReferenceSystem}, {@link Datum}, {@link CoordinateOperation}</td></tr>
     *   <tr><td>{@code TimeExtent[…]}</td>    <td></td> <td>{@link ReferenceSystem}, {@link Datum}, {@link CoordinateOperation}</td></tr>
     *   <tr><td>{@code Id[…]}</td><td>{@code Authority[…]}</td><td>{@link IdentifiedObject}</td></tr>
     *   <tr><td>{@code Remarks[…]}</td>       <td></td> <td>{@link ReferenceSystem}, {@link CoordinateOperation}</td></tr>
     * </table></blockquote>
     *
     * @param  object  the formattable object to append to the WKT, or {@code null} if none.
     */
    public void append(final FormattableObject object) {
        if (object == null) {
            return;
        }
        /*
         * Safety check: ensure that we do not have circular dependencies (e.g. a ProjectedCRS contains
         * a Conversion which may contain the ProjectedCRS as its target CRS). Without this protection,
         * a circular dependency would cause an OutOfMemoryError.
         */
        final int stackDepth = enclosingElements.size();
        for (int i=stackDepth; --i >= 0;) {
            if (enclosingElements.get(i) == object) {
                throw new IllegalStateException(Errors.getResources(locale).getString(Errors.Keys.CircularReference));
            }
        }
        enclosingElements.add(object);
        if (hasContextualUnit < 0) {                            // Test if leftmost bit is set to 1.
            throw new IllegalStateException(Errors.getResources(locale).getString(Errors.Keys.TreeDepthExceedsMaximum));
        }
        hasContextualUnit <<= 1;
        /*
         * Add a new line if it was requested, open the bracket and increase indentation in case the
         * element to format contains other FormattableObject elements.
         */
        appendSeparator();
        int base = buffer.length();
        elementStart = buffer.appendCodePoint(symbols.getOpeningBracket(0)).length();
        indent(+1);
        /*
         * Formats the inner part, then prepend the WKT keyword.
         * The result looks like the following:
         *
         *         <previous text>,
         *           PROJCS["NAD27 / Idaho Central",
         *             GEOGCS[...etc...],
         *             ...etc...
         */
        IdentifiedObject info = (object instanceof IdentifiedObject) ? (IdentifiedObject) object : null;
        String keyword = object.formatTo(this);
        if (keyword == null) {
            if (info != null) {
                setInvalidWKT(info, null);
            } else {
                setInvalidWKT(object.getClass(), null);
            }
            keyword = getName(object.getClass());
        } else if (toUpperCase != 0) {
            final Locale locale = symbols.getLocale();
            keyword = (toUpperCase >= 0) ? keyword.toUpperCase(locale) : keyword.toLowerCase(locale);
        }
        if (highlightError && colors != null) {
            final String color = colors.getAnsiSequence(ElementKind.ERROR);
            if (color != null) {
                buffer.insert(base, color + BACKGROUND_DEFAULT);
                base += color.length();
            }
        }
        highlightError = false;
        buffer.insert(base, keyword);
        /*
         * When formatting geometry coordinates, we may need to shift all numbers by the width
         * of the keyword inserted above in order to keep numbers properly aligned. Exemple:
         *
         *     BOX[ 4.000 -10.000
         *         50.000   2.000]
         */
        if (keywordSpaceAt != null) {
            final int length = keyword.length();
            final CharSequence additionalMargin = CharSequences.spaces(keyword.codePointCount(0, length));
            final int n = keywordSpaceAt.size();
            for (int i=0; i<n;) {
                int p = keywordSpaceAt.getInt(i);
                p += (++i * length);                    // Take in account spaces added previously.
                buffer.insert(p, additionalMargin);
            }
            keywordSpaceAt.clear();
        }
        /*
         * Format the SCOPE["…"], AREA["…"] and other elements. Some of those information
         * are available only for Datum, CoordinateOperation and ReferenceSystem objects.
         */
        if (info == null && convention.majorVersion() != 1 && object instanceof GeneralParameterValue) {
            info = ((GeneralParameterValue) object).getDescriptor();
        }
        if (info != null) {
            appendComplement(info, (stackDepth >= 1) ? enclosingElements.get(stackDepth - 1) : null,
                                   (stackDepth >= 2) ? enclosingElements.get(stackDepth - 2) : null);
        }
        /*
         * Close the bracket, then update the queue of enclosed elements by removing this element.
         */
        buffer.appendCodePoint(symbols.getClosingBracket(0));
        indent(-1);
        enclosingElements.remove(stackDepth);
        hasContextualUnit >>>= 1;
    }

    /**
     * Appends the optional complementary attributes common to many {@link IdentifiedObject} subtypes.
     * Those attributes are {@code ANCHOR}, {@code SCOPE}, {@code AREA}, {@code BBOX}, {@code VERTICALEXTENT},
     * {@code TIMEEXTENT}, {@code ID} (previously known as {@code AUTHORITY}) and {@code REMARKS},
     * and have a special treatment: they are written by {@link #append(FormattableObject)}
     * after the {@code formatTo(Formatter)} method returned.
     *
     * <p>The {@code ID[<name>,<code>,…]} element is normally written only for the root element
     * (unless the convention is {@code INTERNAL}), but there is various exceptions to this rule.
     * If formatted, the {@code ID} element will be by default on the same line than the enclosing
     * element (e.g. {@code SPHEROID["Clarke 1866", …, ID["EPSG", 7008]]}). Other example:</p>
     *
     * {@preformat text
     *   PROJCS["NAD27 / Idaho Central",
     *     GEOGCS[...etc...],
     *     ...etc...
     *     ID["EPSG", 26769]]
     * }
     *
     * For non-internal conventions, all elements other than {@code ID[…]} are formatted
     * only for {@link CoordinateOperation} and root {@link ReferenceSystem} instances,
     * with an exception for remarks of {@code ReferenceSystem} embedded inside {@code CoordinateOperation}.
     * Those restrictions are our interpretation of the following ISO 19162 requirement:
     *
     * <blockquote>(…snip…) {@code <scope extent identifier remark>} is a collection of four optional attributes
     * which may be applied to a coordinate reference system, a coordinate operation or a boundCRS. (…snip…)
     * Identifier (…snip…) may also be utilised for components of these objects although this is not recommended
     * except for coordinate operation methods (including map projections) and parameters. (…snip…)
     * A {@code <remark>} can be included within the descriptions of source and target CRS embedded within
     * a coordinate transformation as well as within the coordinate transformation itself.</blockquote>
     */
    @SuppressWarnings("null")
    private void appendComplement(final IdentifiedObject object, final FormattableObject parent, final FormattableObject gp) {
        isComplement = true;
        final boolean showIDs;      // Whether to format ID[…] elements.
        final boolean filterID;     // Whether we shall limit to a single ID[…] element.
        final boolean showOthers;   // Whether to format any element other than ID[…] and Remarks[…].
        final boolean showRemarks;  // Whether to format Remarks[…].
        if (convention == Convention.INTERNAL) {
            showIDs     = true;
            filterID    = false;
            showOthers  = true;
            showRemarks = true;
        } else {
            /*
             * Except for the special cases of OperationMethod and Parameters, ISO 19162 recommends to format the
             * ID only for the root element.  But Apache SIS adds an other exception to this rule by handling the
             * components of CompoundCRS as if they were root elements. The reason is that users often create their
             * own CompoundCRS from standard components, for example by adding a time axis to some standard CRS like
             * "WGS84". The resulting CompoundCRS usually have no identifier. Then the users often need to extract a
             * particular component of a CompoundCRS, most often the horizontal part, and will need its identifier
             * for example in a Web Map Service (WMS). Those ID are lost if we do not format them here.
             */
            if (parent == null || parent instanceof CompoundCRS) {
                showIDs = true;
            } else if (gp instanceof CoordinateOperation && !(parent instanceof IdentifiedObject)) {
                // "SourceCRS[…]" and "TargetCRS[…]" sub-elements in CoordinateOperation.
                showIDs = true;
            } else if (convention == Convention.WKT2_SIMPLIFIED) {
                showIDs = false;
            } else {
                showIDs = (object instanceof OperationMethod) || (object instanceof GeneralParameterDescriptor);
            }
            if (convention.majorVersion() == 1) {
                filterID    = true;
                showOthers  = false;
                showRemarks = false;
            } else {
                filterID = (parent != null);
                if (object instanceof CoordinateOperation) {
                    showOthers  = !(parent instanceof ConcatenatedOperation);
                    showRemarks = showOthers;
                } else if (object instanceof ReferenceSystem) {
                    showOthers  = (parent == null);
                    showRemarks = (parent == null) || (gp instanceof CoordinateOperation);
                } else {
                    showOthers  = false;    // Mandated by ISO 19162.
                    showRemarks = false;
                }
            }
        }
        if (showOthers) {
            appendForSubtypes(object);
        }
        if (showIDs) {
            Collection<ReferenceIdentifier> identifiers = object.getIdentifiers();
            if (identifiers != null) {                                                  // Paranoiac check
                if (filterID) {
                    for (final ReferenceIdentifier id : identifiers) {
                        if (Citations.identifierMatches(authority, id.getAuthority())) {
                            identifiers = Collections.singleton(id);
                            break;
                        }
                    }
                }
                for (ReferenceIdentifier id : identifiers) {
                    if (!(id instanceof FormattableObject)) {
                        id = ImmutableIdentifier.castOrCopy(id);
                    }
                    append((FormattableObject) id);
                    if (filterID) break;
                }
            }
        }
        if (showRemarks) {
            appendOnNewLine(WKTKeywords.Remark, object.getRemarks(), ElementKind.REMARKS);
        }
        isComplement = false;
    }

    /**
     * Appends the anchor, scope and domain of validity of the given object. Those information are available
     * only for {@link ReferenceSystem}, {@link Datum} and {@link CoordinateOperation} objects.
     */
    private void appendForSubtypes(final IdentifiedObject object) {
        final InternationalString anchor, scope;
        final Extent area;
        if (object instanceof ReferenceSystem) {
            anchor = null;
            scope  = ((ReferenceSystem) object).getScope();
            area   = ((ReferenceSystem) object).getDomainOfValidity();
        } else if (object instanceof Datum) {
            anchor = ((Datum) object).getAnchorPoint();
            scope  = ((Datum) object).getScope();
            area   = ((Datum) object).getDomainOfValidity();
        } else if (object instanceof CoordinateOperation) {
            anchor = null;
            scope  = ((CoordinateOperation) object).getScope();
            area   = ((CoordinateOperation) object).getDomainOfValidity();
        } else {
            return;
        }
        appendOnNewLine(WKTKeywords.Anchor, anchor, null);
        appendOnNewLine(WKTKeywords.Scope, scope, ElementKind.SCOPE);
        if (area != null) {
            appendOnNewLine(WKTKeywords.Area, area.getDescription(), ElementKind.EXTENT);
            append(Extents.getGeographicBoundingBox(area), BBOX_ACCURACY);
            appendVerticalExtent(Extents.getVerticalRange(area));
            appendTemporalExtent(Extents.getTimeRange(area));
        }
    }

    /**
     * Appends the given geographic bounding box in a {@code BBOX[…]} element.
     * Longitude and latitude values will be formatted in decimal degrees.
     * Longitudes are relative to the Greenwich meridian, with values increasing toward East.
     * Latitudes values are increasing toward North.
     *
     * <div class="section">Numerical precision</div>
     * The ISO 19162 standards recommends to format those values with only 2 decimal digits.
     * This is because {@code GeographicBoundingBox} does not specify the datum, so this box
     * is an approximated information only.
     *
     * @param  bbox  the geographic bounding box to append to the WKT, or {@code null}.
     * @param  fractionDigits  the number of fraction digits to use. The recommended value is 2.
     */
    public void append(final GeographicBoundingBox bbox, final int fractionDigits) {
        if (bbox != null) {
            openElement(isComplement, WKTKeywords.BBox);
            setColor(ElementKind.EXTENT);
            numberFormat.setMinimumFractionDigits(fractionDigits);
            numberFormat.setMaximumFractionDigits(fractionDigits);
            numberFormat.setRoundingMode(RoundingMode.FLOOR);
            appendPreset(bbox.getSouthBoundLatitude());
            appendPreset(bbox.getWestBoundLongitude());
            numberFormat.setRoundingMode(RoundingMode.CEILING);
            appendPreset(bbox.getNorthBoundLatitude());
            appendPreset(bbox.getEastBoundLongitude());
            resetColor();
            closeElement(isComplement);
        }
    }

    /**
     * Appends the given vertical extent, if non-null.
     * This method chooses an accuracy from the vertical span.
     * Examples:
     *
     * <ul>
     *   <li>“{@code VerticalExtent[102, 108, LengthUnit["m", 1]]}”       (Δz =   6)</li>
     *   <li>“{@code VerticalExtent[100.2, 100.8, LengthUnit["m", 1]]}”   (Δz = 0.6)</li>
     * </ul>
     *
     * Note that according ISO 19162, heights are positive toward up and relative to an unspecified mean sea level.
     * It is caller's responsibility to ensure that the given range complies with that specification as much as possible.
     */
    private void appendVerticalExtent(final MeasurementRange<Double> range) {
        if (range != null) {
            final double min = range.getMinDouble();
            final double max = range.getMaxDouble();
            int minimumFractionDigits = Numerics.fractionDigitsForDelta(max - min);
            int maximumFractionDigits = Math.min(Math.min(
                    Numerics.suggestFractionDigits(min, max),
                    minimumFractionDigits + 2), VERTICAL_ACCURACY);             // Arbitrarily limit to 2 more digits.
            openElement(true, WKTKeywords.VerticalExtent);
            setColor(ElementKind.EXTENT);
            numberFormat.setMinimumFractionDigits(minimumFractionDigits);
            numberFormat.setMaximumFractionDigits(maximumFractionDigits);
            numberFormat.setRoundingMode(RoundingMode.FLOOR);   appendPreset(min);
            numberFormat.setRoundingMode(RoundingMode.CEILING); appendPreset(max);
            final Unit<?> unit = range.unit();
            if (!convention.isSimplified() || !Units.METRE.equals(unit)) {
                append(unit);                                               // Unit are optional if they are metres.
            }
            resetColor();
            closeElement(true);
        }
    }

    /**
     * Appends the given temporal extent, if non-null.
     * Examples:
     *
     * <ul>
     *   <li>“{@code TemporalExtent[1980-04-12, 1980-04-18]}”</li>
     *   <li>“{@code TemporalExtent[1980-04-12T18:00:00.0Z, 1980-04-12T21:00:00.0Z]}”</li>
     * </ul>
     */
    private void appendTemporalExtent(final Range<Date> range) {
        if (range != null) {
            final Date min = range.getMinValue();
            final Date max = range.getMaxValue();
            if (min != null && max != null) {
                openElement(true, WKTKeywords.TimeExtent);
                setColor(ElementKind.EXTENT);
                append(min);
                append(max);
                resetColor();
                closeElement(true);
            }
        }
    }

    /**
     * Appends the given math transform, typically (but not necessarily) in a {@code PARAM_MT[…]} element.
     *
     * @param  transform  the transform object to append to the WKT, or {@code null} if none.
     */
    public void append(final MathTransform transform) {
        if (transform != null) {
            if (transform instanceof FormattableObject) {
                append((FormattableObject) transform);
            } else {
                final FormattableObject object = WKTUtilities.toFormattable(transform, convention == Convention.INTERNAL);
                if (object != null) {
                    append(object);
                } else {
                    throw new UnformattableObjectException(Errors.format(
                            Errors.Keys.IllegalClass_2, FormattableObject.class, transform.getClass()));
                }
            }
        }
    }

    /**
     * Appends an international text in an element having the given keyword. Since this method
     * is typically invoked for long descriptions, the element will be written on its own line.
     *
     * <div class="note"><b>Example:</b>
     *   <ul>
     *     <li>{@code Scope["Large scale topographic mapping and cadastre."]}</li>
     *     <li>{@code Area["Netherlands offshore."]}</li>
     *   </ul>
     * </div>
     *
     * @param  keyword  the {@linkplain KeywordCase#CAMEL_CASE camel-case} keyword.
     *                  Example: {@code "Scope"}, {@code "Area"} or {@code "Remarks"}.
     * @param  text     the text, or {@code null} if none.
     * @param  type     the key of the colors to apply if syntax coloring is enabled.
     */
    private void appendOnNewLine(final String keyword, final InternationalString text, final ElementKind type) {
        ArgumentChecks.ensureNonNull("keyword", keyword);
        if (text != null) {
            final String localized = CharSequences.trimWhitespaces(text.toString(locale));
            if (localized != null && !localized.isEmpty()) {
                openElement(true, keyword);
                quote(localized, type);
                closeElement(true);
            }
        }
    }

    /**
     * Appends a character string between quotes.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the text if needed.
     *
     * @param  text  the string to format to the WKT, or {@code null} if none.
     * @param  type  the key of the colors to apply if syntax coloring is enabled, or {@code null} if none.
     */
    public void append(final String text, final ElementKind type) {
        if (text != null) {
            appendSeparator();
            if (type != ElementKind.CODE_LIST) {
                quote(text, type);
            } else {
                /*
                 * Code lists have no quotes. They are normally formatted by the append(ControlledVocabulary) method,
                 * but an important exception is the CS[type] element in which the type is defined by the interface
                 * implemented by the CoordinateSystem rather than a CodeList instance.
                 */
                setColor(type);
                buffer.append(text);
                resetColor();
            }
        }
    }

    /**
     * Appends the given string as a quoted text. If the given string contains the closing quote character,
     * that character will be doubled (WKT 2) or deleted (WKT 1). We check for the closing quote only because
     * it is the character that the parser will look for determining the text end.
     */
    private void quote(String text, final ElementKind type) {
        setColor(type);
        final int base = buffer.appendCodePoint(symbols.getOpeningQuote(0)).length();
        if (type != ElementKind.REMARKS) {
            text = transliterator.filter(text);
            if (verifyCharacterValidity) {
                int startAt = 0;                                        // Index of the last space character.
                final int length = text.length();
                for (int i = 0; i < length;) {
                    int c = text.codePointAt(i);
                    int n = Character.charCount(c);
                    if (!Characters.isValidWKT(c)) {
                        final String illegal = text.substring(i, i+n);
                        while ((i += n) < length) {
                            c = text.codePointAt(i);
                            n = Character.charCount(c);
                            if (c == ' ' || c == '_') break;
                        }
                        warnings().add(Errors.formatInternational(Errors.Keys.IllegalCharacterForFormat_3,
                                "Well-Known Text", text.substring(startAt, i), illegal), null, null);
                        break;
                    }
                    i += n;
                    if (c == ' ' || c == '_') {
                        startAt = i;
                    }
                }
            }
        }
        buffer.append(text);
        closeQuote(base);
        resetColor();
    }

    /**
     * Double or delete any closing quote character that may appear at or after the given index,
     * then append the closing quote character. The action taken for the quote character depends
     * on the WKT version:
     *
     * <ul>
     *   <li>For WKT 2, double the quote as specified in the standard.</li>
     *   <li>For WKT 1, conservatively delete the quote because the standard does not said what to do.</li>
     * </ul>
     */
    private void closeQuote(int fromIndex) {
        final String quote = symbols.getQuote();
        while ((fromIndex = buffer.indexOf(quote, fromIndex)) >= 0) {
            final int n = quote.length();
            if (convention.majorVersion() == 1) {
                buffer.delete(fromIndex, fromIndex + n);
            } else {
                buffer.insert(fromIndex += n, quote);
                fromIndex += n;
            }
        }
        buffer.append(quote);
    }

    /**
     * Appends an enumeration or code list value.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the code list if needed.
     *
     * <p>For the WKT 2 format, this method uses the {@linkplain Types#getCodeName ISO name if available}
     * (for example {@code "northEast"}).
     * For the WKT 1 format, this method uses the programmatic name instead (for example {@code "NORTH_EAST"}).</p>
     *
     * @param  code  the code list to append to the WKT, or {@code null} if none.
     */
    public void append(final CodeList<?> code) {
        if (code != null) {
            appendSeparator();
            final String name = convention.majorVersion() == 1 ? code.name() : Types.getCodeName(code);
            if (CharSequences.isUnicodeIdentifier(name)) {
                setColor(ElementKind.CODE_LIST);
                buffer.append(name);
                resetColor();
            } else {
                quote(name, ElementKind.CODE_LIST);
                setInvalidWKT(code.getClass(), null);
            }
        }
    }

    /**
     * Appends a date.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the date if needed.
     *
     * @param  date  the date to append to the WKT, or {@code null} if none.
     */
    public void append(final Date date) {
        if (date != null) {
            appendSeparator();
            dateFormat.format(date, buffer, dummy);
        }
    }

    /**
     * Appends a boolean value.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the boolean if needed.
     *
     * @param  value  the boolean to append to the WKT.
     */
    public void append(final boolean value) {
        appendSeparator();
        buffer.append(value ? "TRUE" : "FALSE");
    }

    /**
     * Appends an integer value.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the number if needed.
     *
     * @param  number  the integer to append to the WKT.
     */
    public void append(final long number) {
        appendSeparator();
        /*
         * The check for 'isComplement' is a hack for ImmutableIdentifier.formatTo(Formatter).
         * We do not have a public API for controlling the integer colors (it may not be desirable).
         */
        setColor(isComplement ? ElementKind.IDENTIFIER : ElementKind.INTEGER);
        numberFormat.setMaximumFractionDigits(0);
        numberFormat.format(number, buffer, dummy);
        resetColor();
    }

    /**
     * Appends an floating point value.
     * The {@linkplain Symbols#getSeparator() element separator} will be written before the number if needed.
     *
     * @param  number  the floating point value to append to the WKT.
     */
    public void append(final double number) {
        appendSeparator();
        setColor(ElementKind.NUMBER);
        /*
         * Use scientific notation if the number magnitude is too high or too low. The threshold values used here
         * may be different than the threshold values used in the standard 'StringBuilder.append(double)' method.
         * In particular, we use a higher threshold for large numbers because ellipsoid axis lengths are above the
         * JDK threshold when the axis length is given in feet (about 2.1E+7) while we still want to format them
         * as usual numbers.
         *
         * Note that we perform this special formatting only if the 'NumberFormat' is not localized
         * (which is the usual case).
         */
        if (symbols.useScientificNotation(Math.abs(number))) {
            buffer.append(number);
        } else {
            /*
             * The 2 below is for using two less fraction digits than the expected number accuracy.
             * The intent is to give to DecimalFormat a chance to hide rounding errors, keeping in
             * mind that the number value is not necessarily the original one (we may have applied
             * a unit conversion). In the case of WGS84 semi-major axis in metres, we still have a
             * maximum of 8 fraction digits, which is more than enough.
             */
            numberFormat.setMaximumFractionDigits(DecimalFunctions.fractionDigitsForValue(number, 2));
            numberFormat.setMinimumFractionDigits(1);   // Must be after setMaximumFractionDigits(…).
            numberFormat.setRoundingMode(RoundingMode.HALF_EVEN);
            numberFormat.format(number, buffer, dummy);
        }
        resetColor();
    }

    /**
     * Appends rows of numbers. Each number is separated by a space, and each row is separated by a comma.
     * Rows usually have all the same length, but this is not mandatory.
     * This method can be used for formatting geometries or matrix.
     *
     * @param  rows            the rows to append, or {@code null} if none.
     * @param  fractionDigits  the number of fraction digits for each column in a row, or {@code null} for default.
     *         A precision can be specified for each column because those columns are often different dimensions of
     *         a Coordinate Reference System (CRS), each with their own units of measurement.
     *         If a row contains more numbers than {@code fractionDigits.length},
     *         then the last value in this array is repeated for all remaining row numbers.
     *
     * @since 1.0
     */
    public void append(final Vector[] rows, int... fractionDigits) {
        if (rows == null || rows.length == 0) {
            return;
        }
        if (fractionDigits == null || fractionDigits.length == 0) {
            fractionDigits = Numerics.suggestFractionDigits(rows);
        }
        numberFormat.setRoundingMode(RoundingMode.HALF_EVEN);
        /*
         * If the rows are going to be formatted on many lines, then we will need to put some margin before each row.
         * If the first row starts on its own line, then the margin will be the usual indentation. But if the first
         * row starts on the same line than previous elements (or the keyword of this element, e.g. "BOX["), then we
         * will need a different amount of spaces if we want to have the numbers properly aligned.
         */
        final int numRows = rows.length;
        final boolean isMultiLines = (indentation > WKTFormat.SINGLE_LINE) && (numRows > 1);
        final boolean needsAlignment = !requestNewLine;
        final CharSequence marginBeforeRow;
        if (isMultiLines) {
            int currentLineLength = margin;
            if (needsAlignment) {
                final int length = buffer.length();
                int i = length;
                while (i > 0) {                                         // Locate beginning of current line.
                    final int c = buffer.codePointBefore(i);
                    if (Characters.isLineOrParagraphSeparator(c)) break;
                    i -= Character.charCount(c);
                }
                currentLineLength = buffer.codePointCount(i, length);
            }
            marginBeforeRow = CharSequences.spaces(currentLineLength);
        } else {
            marginBeforeRow = "";
        }
        /*
         * 'formattedNumberMarks' contains, for each number in each row, positions in the 'buffer' where
         * the number starts and position where it ends. Those positions are stored as (start,end) pairs.
         * We compute those marks unconditionally for simplicity, but will ignore them if formatting on
         * a single line.
         */
        final int[][] formattedNumberMarks = new int[numRows][];
        int numColumns = 0;
        for (int j=0; j<numRows; j++) {
            if (j == 0) {
                appendSeparator();      // It is up to the caller to decide if we begin with a new line.
            } else {
                buffer.append(separatorNewLine).append(marginBeforeRow);
            }
            final Vector numbers = rows[j];
            final int numCols = numbers.size();
            numColumns = Math.max(numColumns, numCols);      // Store the length of longest row.
            final int[] marks = new int[numCols << 1];       // Positions where numbers are formatted.
            formattedNumberMarks[j] = marks;
            for (int i=0; i<numCols; i++) {
                if (i != 0) buffer.append(Symbols.NUMBER_SEPARATOR);
                if (i < fractionDigits.length) {                    // Otherwise, same than previous number.
                    final int f = fractionDigits[i];
                    numberFormat.setMaximumFractionDigits(f);
                    numberFormat.setMinimumFractionDigits(f);
                }
                marks[i << 1] = buffer.length();                    // Store the start position where number is formatted.
                setColor(ElementKind.NUMBER);
                final Number n = numbers.get(i);
                if (n != null) {
                    numberFormat.format(n, buffer, dummy);
                } else {
                    buffer.append('…');
                }
                resetColor();
                marks[(i << 1) | 1] = buffer.length();              // Store the end position where number is formatted.
            }
        }
        /*
         * If formatting on more than one line, insert the amount of spaces required for aligning numbers.
         * This is possible because we wrote the coordinate values with fixed number of fraction digits.
         */
        if (isMultiLines) {
            final int base = elementStart;
            final String toWrite = buffer.substring(base);          // Save what we formatted in above loop.
            buffer.setLength(base);                                 // Discard what we formatted - we will rewrite.
            final int[] columnWidths = new int[numColumns];
            for (final int[] marks : formattedNumberMarks) {        // Compute the maximal width of each column.
                for (int i=0; i<marks.length; i += 2) {
                    final int k = i >> 1;
                    final int w = toWrite.codePointCount(marks[i  ] -= base,
                                                         marks[i+1] -= base);
                    if (w > columnWidths[k]) columnWidths[k] = w;
                }
            }
            if (needsAlignment && keywordSpaceAt == null) {
                keywordSpaceAt = new IntegerList(formattedNumberMarks.length, Integer.MAX_VALUE);
            }
            boolean requestAlignment = false;
            int lastPosition = 0;
            for (int[] marks : formattedNumberMarks) {              // Recopy the formatted text, with more spaces.
                for (int i = 0; i<marks.length;) {
                    final int w = columnWidths[i >> 1];
                    final int s = marks[i++];
                    final int e = marks[i++];
                    buffer.append(toWrite, lastPosition, s)
                          .append(CharSequences.spaces(w - toWrite.codePointCount(s, e)));
                    if (requestAlignment) {
                        requestAlignment = false;
                        keywordSpaceAt.add(buffer.length());
                    }
                    buffer.append(toWrite, s, e);
                    lastPosition = e;
                }
                requestAlignment = needsAlignment;
            }
        }
    }

    /**
     * Appends the given number without any change to the {@link NumberFormat} setting.
     * Caller shall ensure that the following method has been invoked prior this method call:
     *
     * <ul>
     *   <li>{@link NumberFormat#setMinimumFractionDigits(int)}</li>
     *   <li>{@link NumberFormat#setMaximumFractionDigits(int)}</li>
     *   <li>{@link NumberFormat#setRoundingMode(RoundingMode)}</li>
     * </ul>
     */
    private void appendPreset(final double number) {
        appendSeparator();
        setColor(ElementKind.NUMBER);
        numberFormat.format(number, buffer, dummy);
        resetColor();
    }

    /**
     * Appends a number which is assumed to have no rounding error greater than the limit of IEEE 754 accuracy.
     * This method is invoked for formatting the unit conversion factors, which are defined by the Unit library
     * rather than specified by the user. The given number is formatted by {@link Double#toString(double)} both
     * for accuracy and for automatic usage of scientific notation.  If the given number is an integer, then it
     * formatted without the trailing ".0".
     */
    private void appendExact(final double number) {
        if (Locale.ROOT.equals(symbols.getLocale())) {
            appendSeparator();
            setColor(highlightError ? ElementKind.ERROR : ElementKind.NUMBER);
            final int i = (int) number;
            if (i == number) {
                buffer.append(i);
            } else {
                buffer.append(number);
            }
            resetColor();
        } else {
            append(number);
        }
        highlightError = false;
    }

    /**
     * Appends a unit in a {@code Unit[…]} element or one of the specialized elements. Specialized elements are
     * {@code AngleUnit}, {@code LengthUnit}, {@code ScaleUnit}, {@code ParametricUnit} and {@code TimeUnit}.
     * By {@linkplain KeywordStyle#DEFAULT default}, specialized unit keywords are used with the
     * {@linkplain Convention#WKT2 WKT 2 convention}.
     *
     * <div class="note"><b>Example:</b>
     * {@code append(Units.KILOMETRE)} will append "{@code LengthUnit["km", 1000]}" to the WKT.</div>
     *
     * @param  unit  the unit to append to the WKT, or {@code null} if none.
     *
     * @see <a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html#35">WKT 2 specification §7.4</a>
     */
    public void append(final Unit<?> unit) {
        if (unit != null) {
            final boolean isSimplified = (longKeywords == 0) ? convention.isSimplified() : (longKeywords < 0);
            final boolean isWKT1 = convention.majorVersion() == 1;
            final Unit<?> base = unit.getSystemUnit();
            final String keyword;
            if (base.equals(Units.METRE)) {
                keyword = isSimplified ? WKTKeywords.Unit : WKTKeywords.LengthUnit;
            } else if (base.equals(Units.RADIAN)) {
                keyword = isSimplified ? WKTKeywords.Unit : WKTKeywords.AngleUnit;
            } else if (base.equals(Units.UNITY)) {
                keyword = isSimplified ? WKTKeywords.Unit : WKTKeywords.ScaleUnit;
            } else if (base.equals(Units.SECOND)) {
                keyword = WKTKeywords.TimeUnit;  // "Unit" alone is not allowed for time units according ISO 19162.
            } else {
                keyword = WKTKeywords.ParametricUnit;
            }
            openElement(false, keyword);
            setColor(ElementKind.UNIT);
            final int fromIndex = buffer.appendCodePoint(symbols.getOpeningQuote(0)).length();
            unitFormat.format(unit, buffer, dummy);
            closeQuote(fromIndex);
            resetColor();
            final double conversion = Units.toStandardUnit(unit);
            if (Double.isNaN(conversion) && Units.isAngular(unit)) {
                appendExact(Math.PI / 180);                 // Presume that we have sexagesimal degrees (see below).
            } else {
                appendExact(conversion);
            }
            /*
             * The EPSG code in UNIT elements is generally not recommended. But we make an exception for sexagesimal
             * units (EPSG:9108, 9110 and 9111) because they can not be represented by a simple scale factor in WKT.
             * Those units are identified by a conversion factor set to NaN since the conversion is non-linear.
             */
            if (convention == Convention.INTERNAL || Double.isNaN(conversion)) {
                final Integer code = Units.getEpsgCode(unit, getEnclosingElement(1) instanceof CoordinateSystemAxis);
                if (code != null) {
                    openElement(false, isWKT1 ? WKTKeywords.Authority : WKTKeywords.Id);
                    append(Constants.EPSG, null);
                    if (isWKT1) {
                        append(code.toString(), null);
                    } else {
                        append(code);
                    }
                    closeElement(false);
                }
            }
            closeElement(false);
            /*
             * ISO 19162 requires the conversion factor to be positive.
             * In addition, keywords other than "Unit" are not valid in WKt 1.
             */
            if (!(conversion > 0) || (keyword != WKTKeywords.Unit && isWKT1)) {
                setInvalidWKT(Unit.class, null);
            }
        }
    }

    /**
     * Appends an object or an array of objects.
     * This method performs the following choices:
     *
     * <ul>
     *   <li>If the given value is {@code null}, then this method appends the "{@code null}" string (without quotes).</li>
     *   <li>Otherwise if the given value is an array, then this method appends the opening sequence symbol, formats all
     *       elements by invoking this method recursively, then appends the closing sequence symbol.</li>
     *   <li>Otherwise if the value type is assignable to the argument type of one of the {@code append(…)} methods
     *       in this class, then the formatting will be delegated to that method.</li>
     *   <li>Otherwise the given value is appended as a quoted text with its {@code toString()} representation.</li>
     * </ul>
     *
     * @param  value  the value to append to the WKT, or {@code null}.
     */
    public void appendAny(final Object value) {
        if (value == null) {
            appendSeparator();
            buffer.append("null");
        } else if (!appendValue(value) && !appendElement(value)) {
            append(value.toString(), null);
        }
    }

    /**
     * Tries to append a small unit of information like number, date, boolean, code list, character string
     * or an array of those. The key difference between this method and {@link #appendElement(Object)} is
     * that the values formatted by this {@code appendValue(Object)} method do not have keyword.
     *
     * @return {@code true} on success, or {@code false} if the given type is not recognized.
     */
    final boolean appendValue(final Object value) {
        if (value instanceof Number) {
            final Number number = (Number) value;
            if (Numbers.isInteger(number.getClass())) {
                append(number.longValue());
            } else {
                append(number.doubleValue());
            }
        }
        else if (value instanceof CodeList<?>) append((CodeList<?>) value);
        else if (value instanceof Date)        append((Date)        value);
        else if (value instanceof Boolean)     append((Boolean)     value);
        else if (value instanceof CharSequence) {
            append((value instanceof InternationalString) ?
                    ((InternationalString) value).toString(locale) : value.toString(), null);
        } else if (value.getClass().isArray()) {
            /*
             * All above cases delegated to another method which invoke 'appendSeparator()'.
             * Since the following block is writing itself a new element, we need to invoke
             * 'appendSeparator()' here. This block invokes (indirectly) this 'appendValue'
             * method recursively for some or all elements in the list.
             */
            appendSeparator();
            elementStart = buffer.appendCodePoint(symbols.getOpenSequence()).length();
            final int length = Array.getLength(value);
            final int cut = (length <= listSizeLimit) ? length : Math.max(listSizeLimit/2 - 1, 1);
            for (int i=0; i<length; i++) {
                if (i == cut) {
                    /*
                     * Skip elements in the middle if the list is too long. The 'cut' index has been computed
                     * in such a way that the number of elements to skip should be greater than 1, otherwise
                     * formatting the single missing element would often have been shorter.
                     */
                    final int skip = length - Math.min(2*cut, listSizeLimit);
                    buffer.append(symbols.getSeparator());
                    setColor(ElementKind.REMARKS);
                    buffer.append(Resources.forLocale(locale).getString(Resources.Keys.ElementsOmitted_1, skip));
                    resetColor();
                    i += skip;
                    setInvalidWKT(value.getClass().getSimpleName(), null);
                }
                appendAny(Array.get(value, i));
            }
            buffer.appendCodePoint(symbols.getCloseSequence());
        } else {
            return false;
        }
        return true;
    }

    /**
     * Tries to append an object of the {@code KEYWORD[something]} form. The given value is typically,
     * but not necessarily, a {@link FormattableObject} object or an instance of an interface that can
     * be converted to {@code FormattableObject}.
     *
     * @return {@code true} on success, or {@code false} if the given type is not recognized.
     */
    final boolean appendElement(final Object value) {
        if (value instanceof FormattableObject) {
            append((FormattableObject) value);
        } else if (value instanceof IdentifiedObject) {
            append(AbstractIdentifiedObject.castOrCopy((IdentifiedObject) value));
        } else if (value instanceof MathTransform) {
            append((MathTransform) value);
        } else if (value instanceof Unit<?>) {
            append((Unit<?>) value);
        } else if (value instanceof GeographicBoundingBox) {
            append((GeographicBoundingBox) value, BBOX_ACCURACY);
        } else if (value instanceof VerticalExtent) {
            appendVerticalExtent(Extents.getVerticalRange(new SimpleExtent(null, (VerticalExtent) value, null)));
        } else if (value instanceof TemporalExtent) {
            appendTemporalExtent(Extents.getTimeRange(new SimpleExtent(null, null, (TemporalExtent) value)));
        } else if (value instanceof Position) {
            append(AbstractDirectPosition.castOrCopy(((Position) value).getDirectPosition()));
        } else if (value instanceof Envelope) {
            append(AbstractEnvelope.castOrCopy((Envelope) value));          // Non-standard
        } else {
            return false;
        }
        return true;
    }

    /**
     * Delegates the formatting to another {@link FormattableObject} implementation.
     * Invoking this method is equivalent to first verifying the {@code other} class,
     * then delegating as below:
     *
     * {@preformat java
     *     return other.formatTo(this);
     * }
     *
     * This method is useful for {@code FormattableObject} which are wrapper around another object.
     * It allows to delegate the WKT formatting to the wrapped object.
     *
     * @param   other  the object to format with this formatter.
     * @return  the value returned by {@link FormattableObject#formatTo(Formatter)}.
     *
     * @since 0.5
     */
    public String delegateTo(final Object other) throws UnformattableObjectException {
        ArgumentChecks.ensureNonNull("other", other);
        if (other instanceof FormattableObject) {
            return ((FormattableObject) other).formatTo(this);
        }
        throw new UnformattableObjectException(Errors.format(
                Errors.Keys.IllegalClass_2, FormattableObject.class, other.getClass()));
    }

    /**
     * Returns the enclosing WKT element, or {@code null} if element being formatted is the root.
     * This method can be invoked by child elements having some aspects that depend on the enclosing element.
     *
     * @param  depth  1 for the immediate parent, 2 for the parent of the parent, <i>etc.</i>
     * @return the parent element at the given depth, or {@code null}.
     */
    public FormattableObject getEnclosingElement(int depth) {
        ArgumentChecks.ensurePositive("depth", depth);
        depth = (enclosingElements.size() - 1) - depth;
        return (depth >= 0) ? enclosingElements.get(depth) : null;
    }

    /**
     * Returns {@code true} if the element at the given depth specified a contextual unit.
     * This method returns {@code true} if the formattable object given by {@code getEnclosingElement(depth)}
     * has invoked {@link #addContextualUnit(Unit)} with a non-null unit at least once.
     *
     * <div class="note"><b>Note:</b>
     * The main purpose of this method is to allow {@code AXIS[…]} elements to determine if they should
     * inherit the unit specified by the enclosing CRS, or if they should specify their unit explicitly.</div>
     *
     * @param  depth  1 for the immediate parent, 2 for the parent of the parent, <i>etc.</i>
     * @return whether the parent element at the given depth has invoked {@code addContextualUnit(…)} at least once.
     */
    public boolean hasContextualUnit(final int depth) {
        ArgumentChecks.ensurePositive("depth", depth);
        return (hasContextualUnit & Numerics.bitmask(depth)) != 0;
    }

    /**
     * Adds a unit to use for the next measurements of the quantity {@code Q}. The given unit will apply to
     * all WKT elements containing a value of quantity {@code Q} without their own {@code UNIT[…]} element,
     * until the {@link #restoreContextualUnit(Unit, Unit)} method is invoked.
     *
     * <p>If the given unit is null, then this method does nothing and returns {@code null}.</p>
     *
     * <div class="section">Special case</div>
     * If the WKT conventions are {@code WKT1_COMMON_UNITS}, then this method ignores the given unit
     * and returns {@code null}. See {@link Convention#WKT1_COMMON_UNITS} javadoc for more information.
     *
     * @param  <Q>   the unit quantity.
     * @param  unit  the contextual unit to add, or {@code null} if none.
     * @return the previous contextual unit for quantity {@code Q}, or {@code null} if none.
     */
    @SuppressWarnings("unchecked")
    public <Q extends Quantity<Q>> Unit<Q> addContextualUnit(final Unit<Q> unit) {
        if (unit == null || convention.usesCommonUnits) {
            return null;
        }
        hasContextualUnit |= 1;
        return (Unit<Q>) units.put(unit.getSystemUnit(), unit);
    }

    /**
     * Restores the contextual unit to its previous state before the call to {@link #addContextualUnit(Unit)}.
     * This method is used in the following pattern:
     *
     * {@preformat java
     *   final Unit<?> previous = formatter.addContextualUnit(unit);
     *   // ... format some WKT elements here.
     *   formatter.restoreContextualUnit(unit, previous);
     * }
     *
     * @param  unit      the value given in argument to {@code addContextualUnit(unit)} (can be {@code null}).
     * @param  previous  the value returned by {@code addContextualUnit(unit)} (can be {@code null}).
     * @throws IllegalStateException if this method has not been invoked in the pattern documented above.
     *
     * @since 0.6
     */
    public void restoreContextualUnit(final Unit<?> unit, final Unit<?> previous) {
        if (previous == null) {
            if (unit != null && units.remove(unit.getSystemUnit()) != unit) {
                /*
                 * The unit that we removed was not the expected one. Probably the user has invoked
                 * addContextualUnit(…) again without a matching call to restoreContextualUnit(…).
                 * However this check does not work in Convention.WKT1_COMMON_UNITS mode, since the
                 * map is always empty in that mode.
                 */
                if (!convention.usesCommonUnits) {
                    throw new IllegalStateException();
                }
            }
            hasContextualUnit &= ~1;
        } else if (units.put(previous.getSystemUnit(), previous) != unit) {
            /*
             * The unit that we replaced was not the expected one. Probably the user has invoked
             * addContextualUnit(…) again without a matching call to restoreContextualUnit(…).
             * Note that this case should never happen in Convention.WKT1_COMMON_UNITS mode,
             * since 'previous' should never be non-null in that mode (if the user followed
             * the documented pattern).
             */
            throw new IllegalStateException();
        }
    }

    /**
     * Returns the unit to use instead than the given one, or {@code unit} if there is no replacement.
     * This method searches for a unit specified by {@link #addContextualUnit(Unit)}
     * which {@linkplain Unit#isCompatible(Unit) is compatible} with the given unit.
     *
     * @param  <Q>   the quantity of the unit.
     * @param  unit  the unit to replace by the contextual unit, or {@code null}.
     * @return a contextual unit compatible with the given unit, or {@code unit}
     *         (which may be null) if no contextual unit has been found.
     */
    public <Q extends Quantity<Q>> Unit<Q> toContextualUnit(final Unit<Q> unit) {
        if (unit != null) {
            @SuppressWarnings("unchecked")
            final Unit<Q> candidate = (Unit<Q>) units.get(unit.getSystemUnit());
            if (candidate != null) {
                return candidate;
            }
        }
        return unit;
    }

    /**
     * Returns {@code true} if the WKT written by this formatter is not strictly compliant to the WKT specification.
     * This method returns {@code true} if {@link #setInvalidWKT(IdentifiedObject, Exception)} has been invoked at
     * least once. The action to take regarding invalid WKT is caller-dependent.
     * For example {@link FormattableObject#toString()} will accepts loose WKT formatting and ignore
     * this flag, while {@link FormattableObject#toWKT()} requires strict WKT formatting and will
     * thrown an exception if this flag is set.
     *
     * @return {@code true} if the WKT is invalid.
     */
    public boolean isInvalidWKT() {
        return (warnings != null) || (buffer != null && buffer.length() == 0);
        /*
         * Note: we really use a "and" condition (not an other "or") for the buffer test because
         *       the buffer is reset to 'null' by WKTFormat after a successfull formatting.
         */
    }

    /**
     * Returns the object where to store warnings.
     */
    private Warnings warnings() {
        if (warnings == null) {
            warnings = new Warnings(locale, false, Collections.emptyMap());
        }
        return warnings;
    }

    /**
     * Marks the current WKT representation of the given object as not strictly compliant with the WKT specification.
     * This method can be invoked by implementations of {@link FormattableObject#formatTo(Formatter)} when the object
     * to format is more complex than what the WKT specification allows.
     * Applications can test {@link #isInvalidWKT()} later for checking WKT validity.
     *
     * @param  unformattable  the object that can not be formatted,
     * @param  cause  the cause for the failure to format, or {@code null} if the cause is not an exception.
     */
    public void setInvalidWKT(final IdentifiedObject unformattable, final Exception cause) {
        ArgumentChecks.ensureNonNull("unformattable", unformattable);
        String name;
        final Identifier id = unformattable.getName();
        if (id == null || (name = id.getCode()) == null) {
            name = getName(unformattable.getClass());
        }
        setInvalidWKT(name, cause);
    }

    /**
     * Marks the current WKT representation of the given class as not strictly compliant with the WKT specification.
     * This method can be used as an alternative to {@link #setInvalidWKT(IdentifiedObject, Exception)} when the
     * problematic object is not an instance of {@code IdentifiedObject}.
     *
     * @param  unformattable  the class of the object that can not be formatted,
     * @param  cause  the cause for the failure to format, or {@code null} if the cause is not an exception.
     */
    public void setInvalidWKT(final Class<?> unformattable, final Exception cause) {
        ArgumentChecks.ensureNonNull("unformattable", unformattable);
        setInvalidWKT(getName(unformattable), cause);
    }

    /**
     * Implementation of public {@code setInvalidWKT(…)} methods.
     *
     * <div class="note"><b>Note:</b> the message is stored as an {@link InternationalString}
     * in order to defer the actual message formatting until needed.</div>
     */
    private void setInvalidWKT(final String invalidElement, final Exception cause) {
        warnings().add(Errors.formatInternational(Errors.Keys.CanNotRepresentInFormat_2, "WKT", invalidElement), cause, null);
        highlightError = true;
    }

    /**
     * Returns the name of the GeoAPI interface implemented by the given class.
     * If no GeoAPI interface is found, fallback on the class name.
     */
    private static String getName(Class<?> unformattable) {
        if (!unformattable.isInterface()) {
            for (final Class<?> candidate : unformattable.getInterfaces()) {
                if (candidate.getName().startsWith("org.opengis.")) {
                    unformattable = candidate;
                    break;
                }
            }
        }
        return Classes.getShortName(unformattable);
    }

    /**
     * Returns the warnings, or {@code null} if none.
     */
    final Warnings getWarnings() {
        return warnings;
    }

    /**
     * Appends the warnings after the WKT string. If there is no warnings, then this method does nothing.
     * If this method is invoked, then it shall be the last method before {@link #toWKT()}.
     */
    final void appendWarnings() throws IOException {
        final Warnings warnings = this.warnings;                    // Protect against accidental changes.
        if (warnings != null) {
            final StringBuffer buffer = this.buffer;
            final String ln = System.lineSeparator();
            buffer.append(ln).append(ln);
            if (colors != null) {
                buffer.append(X364.BACKGROUND_RED.sequence()).append(X364.BOLD.sequence()).append(' ');
            }
            Vocabulary.getResources(locale).appendLabel(Vocabulary.Keys.Warnings, buffer);
            if (colors != null) {
                buffer.append(' ').append(X364.RESET.sequence()).append(X364.FOREGROUND_RED.sequence());
            }
            buffer.append(ln);
            final int n = warnings.getNumMessages();
            final Set<String> done = new HashSet<>();
            for (int i=0; i<n; i++) {
                String message = Exceptions.getLocalizedMessage(warnings.getException(i), locale);
                if (message == null) {
                    message = warnings.getMessage(i);
                }
                if (done.add(message)) {
                    buffer.append("  • ").append(message).append(ln);
                }
            }
        }
    }

    /**
     * Returns the WKT formatted by this object.
     *
     * @return the WKT formatted by this formatter.
     */
    public String toWKT() {
        return buffer.toString();
    }

    /**
     * Returns a string representation of this formatter for debugging purpose.
     *
     * @return a string representation of this formatter.
     */
    @Override
    public String toString() {
        final StringBuilder b = new StringBuilder(Classes.getShortClassName(this));
        String separator = " of ";
        for (int i=enclosingElements.size(); --i >= 0;) {
            b.append(separator).append(Classes.getShortClassName(enclosingElements.get(i)));
            separator = " inside ";
        }
        return b.toString();
    }

    /**
     * Clears this formatter before formatting a new object.
     * This method clears also the {@linkplain #isInvalidWKT() WKT validity flag}.
     */
    final void clear() {
        /*
         * Configuration options (indentation, colors, conventions) are left unchanged.
         * We do not mention that fact in the Javadoc because those options do not appear
         * in the Formatter public API (they are in the WKTFormat API instead).
         */
        if (buffer != null) {
            buffer.setLength(0);
        }
        enclosingElements.clear();
        units.clear();
        hasContextualUnit = 0;
        elementStart      = 0;
        colorApplied      = 0;
        margin            = 0;
        keywordSpaceAt    = null;
        requestNewLine    = false;
        isComplement      = false;
        highlightError    = false;
        warnings          = null;
    }
}
