<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (19) -->
<title>Formatter (Apache SIS 1.3 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.sis.io.wkt, class: Formatter">
<meta name="generator" content="javadoc/ClassWriterImpl">
<meta name="keywords" content="org.apache.sis.io.wkt.Formatter class">
<meta name="keywords" content="getConvention()">
<meta name="keywords" content="getTransliterator()">
<meta name="keywords" content="getNameAuthority()">
<meta name="keywords" content="getLocale()">
<meta name="keywords" content="newLine()">
<meta name="keywords" content="indent()">
<meta name="keywords" content="shortOrLong()">
<meta name="keywords" content="append()">
<meta name="keywords" content="appendAny()">
<meta name="keywords" content="delegateTo()">
<meta name="keywords" content="getEnclosingElement()">
<meta name="keywords" content="hasContextualUnit()">
<meta name="keywords" content="addContextualUnit()">
<meta name="keywords" content="restoreContextualUnit()">
<meta name="keywords" content="toContextualUnit()">
<meta name="keywords" content="isInvalidWKT()">
<meta name="keywords" content="setInvalidWKT()">
<meta name="keywords" content="toWKT()">
<meta name="keywords" content="toString()">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../sis.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.6.0.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top"><button id="navbar-toggle-button" aria-controls="navbar-top" aria-expanded="false" aria-label="Toggle navigation links"><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span></button>
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/Formatter.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
<ul class="sub-nav-list-small">
<li>
<p>Summary:</p>
<ul>
<li>Nested</li>
<li>Field</li>
<li><a href="#constructor-summary">Constr</a></li>
<li><a href="#method-summary">Method</a></li>
</ul>
</li>
<li>
<p>Detail:</p>
<ul>
<li>Field</li>
<li><a href="#constructor-detail">Constr</a></li>
<li><a href="#method-detail">Method</a></li>
</ul>
</li>
</ul>
</div>
<div class="sub-nav">
<div id="navbar-sub-list">
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><a href="../../../../../search.html">SEARCH</a>
<input type="text" id="search-input" disabled placeholder="Search">
<input type="reset" id="reset-button" disabled value="reset">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.io.wkt</a></div>
<h1 title="Class Formatter" class="title">Class Formatter</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
<div class="inheritance">Formatter</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">Formatter</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></span></div>
<div class="block">Provides support methods for formatting a <cite>Well Known Text</cite> (WKT).

 <p><code>Formatter</code> instances are created by <a href="WKTFormat.html" title="class in org.apache.sis.io.wkt"><code>WKTFormat</code></a> and given to the
 <a href="FormattableObject.html#formatTo(org.apache.sis.io.wkt.Formatter)"><code>Formattable­Object​.format­To(Formatter)</code></a> method of the object to format.
 <code>Formatter</code> provides the following services:</p>

 <ul>
   <li>A series of <code>append(…)</code> methods to be invoked by the <code>format­To(Formatter)</code> implementations.</li>
   <li>Contextual information. In particular, the <a href="#toContextualUnit(javax.measure.Unit)">contextual units</a> depend on
       the <a href="#getEnclosingElement(int)">enclosing WKT element</a>.</li>
   <li>A flag for declaring the object unformattable.</li>
 </ul></div>
<dl class="notes">
<dt>Since:</dt>
<dd>0.4</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html">WKT 2 specification</a></li>
<li><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/doc-files/WKT.html">Legacy WKT 1</a></li>
</ul>
</dd>

<p><font size="-1">Defined in the <code>sis-referencing</code> module</font></p>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">Formatter</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new formatter instance with the default configuration.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.sis.io.wkt.Convention,org.apache.sis.io.wkt.Symbols,int)" class="member-name-link">Formatter</a><wbr>(<a href="Convention.html" title="enum class in org.apache.sis.io.wkt">Convention</a>&nbsp;convention,
 <a href="Symbols.html" title="class in org.apache.sis.io.wkt">Symbols</a>&nbsp;symbols,
 int&nbsp;indentation)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new formatter instance with the specified convention, symbols and indentation.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html" title="class or interface in javax.measure" class="external-link">Quantity</a>&lt;Q&gt;&gt;<br><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addContextualUnit(javax.measure.Unit)" class="member-name-link">add­Contextual­Unit</a><wbr>(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;&nbsp;unit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a unit to use for the next measurements of the quantity <code>Q</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(boolean)" class="member-name-link">append</a><wbr>(boolean&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a boolean value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(double)" class="member-name-link">append</a><wbr>(double&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an floating point value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(long)" class="member-name-link">append</a><wbr>(long&nbsp;number)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an integer value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(java.lang.String,org.apache.sis.io.wkt.ElementKind)" class="member-name-link">append</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text,
 <a href="ElementKind.html" title="enum class in org.apache.sis.io.wkt">Element­Kind</a>&nbsp;type)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a character string between quotes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(java.util.Date)" class="member-name-link">append</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;date)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a date.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(javax.measure.Unit)" class="member-name-link">append</a><wbr>(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a unit in a <code>Unit[…]</code> element or one of the specialized elements.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.apache.sis.io.wkt.FormattableObject)" class="member-name-link">append</a><wbr>(<a href="FormattableObject.html" title="class in org.apache.sis.io.wkt">Formattable­Object</a>&nbsp;object)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends the given <code>Formattable­Object</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.apache.sis.math.Vector%5B%5D,int...)" class="member-name-link">append</a><wbr>(<a href="../../math/Vector.html" title="class in org.apache.sis.math">Vector</a>[]&nbsp;rows,
 int...&nbsp;fraction­Digits)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends rows of numbers.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.opengis.metadata.extent.GeographicBoundingBox,int)" class="member-name-link">append</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/metadata/extent/GeographicBoundingBox.html" title="class or interface in org.opengis.metadata.extent" class="external-link">Geographic­Bounding­Box</a>&nbsp;bbox,
 int&nbsp;fraction­Digits)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends the given geographic bounding box in a <code>BBOX[…]</code> element.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.opengis.referencing.operation.MathTransform)" class="member-name-link">append</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends the given math transform, typically (but not necessarily) in a <code>PARAM_MT[…]</code> element.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.opengis.util.CodeList)" class="member-name-link">append</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/CodeList.html" title="class or interface in org.opengis.util" class="external-link">Code­List</a>&lt;?&gt;&nbsp;code)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an enumeration or code list value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#appendAny(java.lang.Object)" class="member-name-link">append­Any</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends an object or an array of objects.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#delegateTo(java.lang.Object)" class="member-name-link">delegate­To</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;other)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Delegates the formatting to another <a href="FormattableObject.html" title="class in org.apache.sis.io.wkt"><code>Formattable­Object</code></a> implementation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final <a href="Convention.html" title="enum class in org.apache.sis.io.wkt">Convention</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getConvention()" class="member-name-link">get­Convention</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the convention to use for formatting the WKT.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="FormattableObject.html" title="class in org.apache.sis.io.wkt">Formattable­Object</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getEnclosingElement(int)" class="member-name-link">get­Enclosing­Element</a><wbr>(int&nbsp;depth)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the enclosing WKT element, or <code>null</code> if element being formatted is the root.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLocale()" class="member-name-link">get­Locale</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the locale to use for localizing <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/InternationalString.html" title="class or interface in org.opengis.util" class="external-link"><code>International­String</code></a> instances.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/metadata/citation/Citation.html" title="class or interface in org.opengis.metadata.citation" class="external-link">Citation</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNameAuthority()" class="member-name-link">get­Name­Authority</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the preferred authority for choosing the projection and parameter names.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final <a href="Transliterator.html" title="class in org.apache.sis.io.wkt">Transliterator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTransliterator()" class="member-name-link">get­Transliterator</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a mapper between Java character sequences and the characters to write in WKT.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#hasContextualUnit(int)" class="member-name-link">has­Contextual­Unit</a><wbr>(int&nbsp;depth)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns <code>true</code> if the element at the given depth specified a contextual unit.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#indent(int)" class="member-name-link">indent</a><wbr>(int&nbsp;amount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Increases or decreases the indentation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isInvalidWKT()" class="member-name-link">is­Invalid­WKT</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns <code>true</code> if the WKT written by this formatter is not strictly compliant to the WKT specification.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#newLine()" class="member-name-link">new­Line</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Request a line separator before the next element to format.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#restoreContextualUnit(javax.measure.Unit,javax.measure.Unit)" class="member-name-link">restore­Contextual­Unit</a><wbr>(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit,
 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;previous)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Restores the contextual unit to its previous state before the call to <a href="#addContextualUnit(javax.measure.Unit)"><code>add­Contextual­Unit(Unit)</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setInvalidWKT(java.lang.Class,java.lang.Exception)" class="member-name-link">set­Invalid­WKT</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;unformattable,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;cause)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Marks the current WKT representation of the given class as not strictly compliant with the WKT specification.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setInvalidWKT(org.opengis.referencing.IdentifiedObject,java.lang.Exception)" class="member-name-link">set­Invalid­WKT</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link">Identified­Object</a>&nbsp;unformattable,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;cause)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Marks the current WKT representation of the given object as not strictly compliant with the WKT specification.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#shortOrLong(java.lang.String,java.lang.String)" class="member-name-link">short­Or­Long</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;short­Keyword,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;long­Keyword)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Selects a short or long keyword depending on the <a href="KeywordStyle.html" title="enum class in org.apache.sis.io.wkt"><code>Keyword­Style</code></a> value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html" title="class or interface in javax.measure" class="external-link">Quantity</a>&lt;Q&gt;&gt;<br><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toContextualUnit(javax.measure.Unit)" class="member-name-link">to­Contextual­Unit</a><wbr>(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;&nbsp;unit)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the unit to use instead of the given one, or <code>unit</code> if there is no replacement.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toString()" class="member-name-link">to­String</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a string representation of this formatter for debugging purpose.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toWKT()" class="member-name-link">to­WKT</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the WKT formatted by this object.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-Object">Methods inherited from class&nbsp;<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">get­Class</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hash­Code</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notify­All</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>Formatter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">Formatter</span>()</div>
<div class="block">Creates a new formatter instance with the default configuration.</div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.sis.io.wkt.Convention,org.apache.sis.io.wkt.Symbols,int)">
<h3>Formatter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">Formatter</span><wbr><span class="parameters">(<a href="Convention.html" title="enum class in org.apache.sis.io.wkt">Convention</a>&nbsp;convention,
 <a href="Symbols.html" title="class in org.apache.sis.io.wkt">Symbols</a>&nbsp;symbols,
 int&nbsp;indentation)</span></div>
<div class="block">Creates a new formatter instance with the specified convention, symbols and indentation.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>convention</code> - the convention to use.</dd>
<dd><code>symbols</code> - the symbols.</dd>
<dd><code>indentation</code> - the amount of spaces to use in indentation for WKT formatting,
                      or <a href="WKTFormat.html#SINGLE_LINE"><code>WKTFormat​.SINGLE_LINE</code></a> for formatting the whole WKT on a single line.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getConvention()">
<h3>getConvention</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="Convention.html" title="enum class in org.apache.sis.io.wkt">Convention</a></span>&nbsp;<span class="element-name">getConvention</span>()</div>
<div class="block">Returns the convention to use for formatting the WKT. The default is <a href="Convention.html#WKT2"><code>Convention​.WKT2</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the convention (never <code>null</code>).</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="WKTFormat.html#setConvention(org.apache.sis.io.wkt.Convention)"><code>WKTFormat​.set­Convention(Convention)</code></a></li>
<li><a href="FormattableObject.html#toString(org.apache.sis.io.wkt.Convention)"><code>Formattable­Object​.to­String(Convention)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTransliterator()">
<h3>getTransliterator</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="Transliterator.html" title="class in org.apache.sis.io.wkt">Transliterator</a></span>&nbsp;<span class="element-name">getTransliterator</span>()</div>
<div class="block">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><a href="Transliterator.html#DEFAULT"><code>Transliterator​.DEFAULT</code></a> for performing replacements like "é" → "e"
       in all WKT elements except <code>REMARKS["…"]</code>.</li>
   <li><a href="Transliterator.html#IDENTITY"><code>Transliterator​.IDENTITY</code></a> for preserving non-ASCII characters.</li>
   <li>Any other user supplied mapping.</li>
 </ul></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the mapper between Java character sequences and the characters to write in WKT.</dd>
<dt>Since:</dt>
<dd>0.6</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="WKTFormat.html#setTransliterator(org.apache.sis.io.wkt.Transliterator)"><code>WKTFormat​.set­Transliterator(Transliterator)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNameAuthority()">
<h3>getNameAuthority</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/metadata/citation/Citation.html" title="class or interface in org.opengis.metadata.citation" class="external-link">Citation</a></span>&nbsp;<span class="element-name">getNameAuthority</span>()</div>
<div class="block">Returns the preferred authority for choosing the projection and parameter names.

 <p>The preferred authority can be set by the <a href="WKTFormat.html#setNameAuthority(org.opengis.metadata.citation.Citation)"><code>WKTFormat​.set­Name­Authority(Citation)</code></a> 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</code> 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></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the authority for projection and parameter names.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="WKTFormat.html#getNameAuthority()"><code>WKTFormat​.get­Name­Authority()</code></a></li>
<li><a href="../../referencing/IdentifiedObjects.html#getName(org.opengis.referencing.IdentifiedObject,org.opengis.metadata.citation.Citation)"><code>Identified­Objects​.get­Name(Identified­Object, Citation)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocale()">
<h3>getLocale</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></span>&nbsp;<span class="element-name">getLocale</span>()</div>
<div class="block">Returns the locale to use for localizing <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/InternationalString.html" title="class or interface in org.opengis.util" class="external-link"><code>International­String</code></a> instances.
 This is <em>not</em> the locale for formatting dates and numbers.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../util/Localized.html#getLocale()">get­Locale</a></code>&nbsp;in interface&nbsp;<code><a href="../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></code></dd>
<dt>Returns:</dt>
<dd>the locale to use for localizing international strings.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newLine()">
<h3>newLine</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">newLine</span>()</div>
<div class="block">Request a line separator before the next element to format. Invoking this method before any
 <code>append(…)</code> 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(…)</code>.</li>
   <li>The indentation is <a href="WKTFormat.html#SINGLE_LINE"><code>WKTFormat​.SINGLE_LINE</code></a>.</li>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="indent(int)">
<h3>indent</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">indent</span><wbr><span class="parameters">(int&nbsp;amount)</span></div>
<div class="block">Increases or decreases the indentation. A value of <code>+1</code> increases
 the indentation by the amount of spaces specified at construction time,
 and a value of <code>-1</code> reduces it by the same amount.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>amount</code> - +1 for increasing the indentation, or -1 for decreasing it, or 0 for no-op.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="shortOrLong(java.lang.String,java.lang.String)">
<h3>shortOrLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">shortOrLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;shortKeyword,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;longKeyword)</span></div>
<div class="block">Selects a short or long keyword depending on the <a href="KeywordStyle.html" title="enum class in org.apache.sis.io.wkt"><code>Keyword­Style</code></a> value.
 This method can be used by <a href="FormattableObject.html#formatTo(org.apache.sis.io.wkt.Formatter)"><code>Formattable­Object​.format­To(Formatter)</code></a>
 implementations for choosing the return value.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>short­Keyword</code> - the keyword to return if the style is <a href="KeywordStyle.html#SHORT"><code>Keyword­Style​.SHORT</code></a>.</dd>
<dd><code>long­Keyword</code> - the keyword to return if the style is <a href="KeywordStyle.html#LONG"><code>Keyword­Style​.LONG</code></a>.</dd>
<dt>Returns:</dt>
<dd>the short or long keyword depending on the keyword style setting.</dd>
<dt>Since:</dt>
<dd>0.6</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="WKTFormat.html#setKeywordStyle(org.apache.sis.io.wkt.KeywordStyle)"><code>WKTFormat​.set­Keyword­Style(Keyword­Style)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.apache.sis.io.wkt.FormattableObject)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="FormattableObject.html" title="class in org.apache.sis.io.wkt">FormattableObject</a>&nbsp;object)</span></div>
<div class="block">Appends the given <code>Formattable­Object</code>.
 This method performs the following steps:

 <ul>
   <li>Invoke <code>object.<a href="FormattableObject.html#formatTo(org.apache.sis.io.wkt.Formatter)">format­To</a>(this)</code>.</li>
   <li>Prepend the keyword returned by the above method call (e.g. <code>"GEOCS"</code>).</li>
   <li>If the given object is an instance of <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link"><code>Identified­Object</code></a>, 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[…]</code></td>        <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a></td></tr>
   <tr><td><code>Scope[…]</code></td>         <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
   <tr><td><code>Area[…]</code></td>          <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
   <tr><td><code>BBox[…]</code></td>          <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
   <tr><td><code>VerticalExtent[…]</code></td><td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
   <tr><td><code>TimeExtent[…]</code></td>    <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/datum/Datum.html" title="class or interface in org.opengis.referencing.datum" class="external-link"><code>Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
   <tr><td><code>Id[…]</code></td><td><code>Authority[…]</code></td><td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link"><code>IdentifiedObject</code></a></td></tr>
   <tr><td><code>Remarks[…]</code></td>       <td></td> <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceSystem.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceSystem</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation</code></a></td></tr>
 </table></blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>object</code> - the formattable object to append to the WKT, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.opengis.metadata.extent.GeographicBoundingBox,int)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/metadata/extent/GeographicBoundingBox.html" title="class or interface in org.opengis.metadata.extent" class="external-link">GeographicBoundingBox</a>&nbsp;bbox,
 int&nbsp;fractionDigits)</span></div>
<div class="block">Appends the given geographic bounding box in a <code>BBOX[…]</code> 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.

 <h4>Numerical precision</h4>
 The ISO 19162 standards recommends to format those values with only 2 decimal digits.
 This is because <code>Geographic­Bounding­Box</code> does not specify the datum, so this box
 is an approximated information only.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bbox</code> - the geographic bounding box to append to the WKT, or <code>null</code>.</dd>
<dd><code>fraction­Digits</code> - the number of fraction digits to use. The recommended value is 2.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.opengis.referencing.operation.MathTransform)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform)</span></div>
<div class="block">Appends the given math transform, typically (but not necessarily) in a <code>PARAM_MT[…]</code> element.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform object to append to the WKT, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(java.lang.String,org.apache.sis.io.wkt.ElementKind)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;text,
 <a href="ElementKind.html" title="enum class in org.apache.sis.io.wkt">ElementKind</a>&nbsp;type)</span></div>
<div class="block">Appends a character string between quotes.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the text if needed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>text</code> - the string to format to the WKT, or <code>null</code> if none.</dd>
<dd><code>type</code> - the key of the colors to apply if syntax coloring is enabled, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.opengis.util.CodeList)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/CodeList.html" title="class or interface in org.opengis.util" class="external-link">CodeList</a>&lt;?&gt;&nbsp;code)</span></div>
<div class="block">Appends an enumeration or code list value.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the code list if needed.

 <p>For the WKT 2 format, this method uses the <a href="../../util/iso/Types.html#getCodeName(org.opengis.util.CodeList)">ISO name if available</a>
 (for example <code>"north­East"</code>).
 For the WKT 1 format, this method uses the programmatic name instead (for example <code>"NORTH_EAST"</code>).</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>code</code> - the code list to append to the WKT, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(java.util.Date)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;date)</span></div>
<div class="block">Appends a date.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the date if needed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>date</code> - the date to append to the WKT, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(boolean)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(boolean&nbsp;value)</span></div>
<div class="block">Appends a boolean value.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the boolean if needed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - the boolean to append to the WKT.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(long)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(long&nbsp;number)</span></div>
<div class="block">Appends an integer value.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the number if needed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>number</code> - the integer to append to the WKT.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(double)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(double&nbsp;number)</span></div>
<div class="block">Appends an floating point value.
 The <a href="Symbols.html#getSeparator()">element separator</a> will be written before the number if needed.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>number</code> - the floating point value to append to the WKT.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.apache.sis.math.Vector[],int...)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="../../math/Vector.html" title="class in org.apache.sis.math">Vector</a>[]&nbsp;rows,
 int...&nbsp;fractionDigits)</span></div>
<div class="block">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.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rows</code> - the rows to append, or <code>null</code> if none.</dd>
<dd><code>fraction­Digits</code> - the number of fraction digits for each column in a row, or <code>null</code> 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>fraction­Digits​.length</code>,
         then the last value in this array is repeated for all remaining row numbers.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(javax.measure.Unit)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit)</span></div>
<div class="block">Appends a unit in a <code>Unit[…]</code> element or one of the specialized elements. Specialized elements are
 <code>Angle­Unit</code>, <code>Length­Unit</code>, <code>Scale­Unit</code>, <code>Parametric­Unit</code> and <code>Time­Unit</code>.
 By <a href="KeywordStyle.html#DEFAULT">default</a>, specialized unit keywords are used with the
 <a href="Convention.html#WKT2">WKT 2 convention</a>.

 <div class="note"><b>Example:</b>
 <code>append(Units​.KILOMETRE)</code> will append "<code>Length­Unit["km", 1000]</code>" to the WKT.</div></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>unit</code> - the unit to append to the WKT, or <code>null</code> if none.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html#35">WKT 2 specification §7.4</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="appendAny(java.lang.Object)">
<h3>appendAny</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">appendAny</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</span></div>
<div class="block">Appends an object or an array of objects.
 This method performs the following choices:

 <ul>
   <li>If the given value is <code>null</code>, then this method appends the "<code>null</code>" 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(…)</code> 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>to­String()</code> representation.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - the value to append to the WKT, or <code>null</code>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="delegateTo(java.lang.Object)">
<h3>delegateTo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">delegateTo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;other)</span>
                  throws <span class="exceptions"><a href="UnformattableObjectException.html" title="class in org.apache.sis.io.wkt">UnformattableObjectException</a></span></div>
<div class="block">Delegates the formatting to another <a href="FormattableObject.html" title="class in org.apache.sis.io.wkt"><code>Formattable­Object</code></a> implementation.
 Invoking this method is equivalent to first verifying the <code>other</code> class,
 then delegating as below:

 <blockquote><pre><font color="green">return</font> other.<b>formatTo</b>(<font color="green">this</font>);</pre></blockquote>

 This method is useful for <code>Formattable­Object</code> which are wrapper around another object.
 It allows to delegate the WKT formatting to the wrapped object.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>other</code> - the object to format with this formatter.</dd>
<dt>Returns:</dt>
<dd>the value returned by <a href="FormattableObject.html#formatTo(org.apache.sis.io.wkt.Formatter)"><code>Formattable­Object​.format­To(Formatter)</code></a>.</dd>
<dt>Throws:</dt>
<dd><code><a href="UnformattableObjectException.html" title="class in org.apache.sis.io.wkt">Unformattable­Object­Exception</a></code></dd>
<dt>Since:</dt>
<dd>0.5</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getEnclosingElement(int)">
<h3>getEnclosingElement</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="FormattableObject.html" title="class in org.apache.sis.io.wkt">FormattableObject</a></span>&nbsp;<span class="element-name">getEnclosingElement</span><wbr><span class="parameters">(int&nbsp;depth)</span></div>
<div class="block">Returns the enclosing WKT element, or <code>null</code> if element being formatted is the root.
 This method can be invoked by child elements having some aspects that depend on the enclosing element.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>depth</code> - 1 for the immediate parent, 2 for the parent of the parent, <i>etc.</i></dd>
<dt>Returns:</dt>
<dd>the parent element at the given depth, or <code>null</code>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasContextualUnit(int)">
<h3>hasContextualUnit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasContextualUnit</span><wbr><span class="parameters">(int&nbsp;depth)</span></div>
<div class="block">Returns <code>true</code> if the element at the given depth specified a contextual unit.
 This method returns <code>true</code> if the formattable object given by <code>get­Enclosing­Element(depth)</code>
 has invoked <a href="#addContextualUnit(javax.measure.Unit)"><code>add­Contextual­Unit(Unit)</code></a> 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[…]</code> elements to determine if they should
 inherit the unit specified by the enclosing CRS, or if they should specify their unit explicitly.</div></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>depth</code> - 1 for the immediate parent, 2 for the parent of the parent, <i>etc.</i></dd>
<dt>Returns:</dt>
<dd>whether the parent element at the given depth has invoked <code>add­Contextual­Unit(…)</code> at least once.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addContextualUnit(javax.measure.Unit)">
<h3>addContextualUnit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html" title="class or interface in javax.measure" class="external-link">Quantity</a>&lt;Q&gt;&gt;</span>&nbsp;<span class="return-type"><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;</span>&nbsp;<span class="element-name">addContextualUnit</span><wbr><span class="parameters">(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;&nbsp;unit)</span></div>
<div class="block">Adds a unit to use for the next measurements of the quantity <code>Q</code>. The given unit will apply to
 all WKT elements containing a value of quantity <code>Q</code> without their own <code>UNIT[…]</code> element,
 until the <a href="#restoreContextualUnit(javax.measure.Unit,javax.measure.Unit)"><code>restore­Contextual­Unit(Unit, Unit)</code></a> method is invoked.

 <p>If the given unit is null, then this method does nothing and returns <code>null</code>.</p>

 <h4>Special case</h4>
 If the WKT conventions are <code>WKT1_COMMON_UNITS</code>, then this method ignores the given unit
 and returns <code>null</code>. See <a href="Convention.html#WKT1_COMMON_UNITS"><code>Convention​.WKT1_COMMON_UNITS</code></a> javadoc for more information.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>Q</code> - the unit quantity.</dd>
<dt>Parameters:</dt>
<dd><code>unit</code> - the contextual unit to add, or <code>null</code> if none.</dd>
<dt>Returns:</dt>
<dd>the previous contextual unit for quantity <code>Q</code>, or <code>null</code> if none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="restoreContextualUnit(javax.measure.Unit,javax.measure.Unit)">
<h3>restoreContextualUnit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">restoreContextualUnit</span><wbr><span class="parameters">(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit,
 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;previous)</span></div>
<div class="block">Restores the contextual unit to its previous state before the call to <a href="#addContextualUnit(javax.measure.Unit)"><code>add­Contextual­Unit(Unit)</code></a>.
 This method is used in the following pattern:

 <blockquote><pre><font color="green">final</font> Unit&lt;?&gt; previous = formatter.<b>addContextualUnit</b>(unit);
<i><font color="gray">// ... format some WKT elements here.</font></i>
formatter.<b>restoreContextualUnit</b>(unit, previous);</pre></blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>unit</code> - the value given in argument to <code>add­Contextual­Unit(unit)</code> (can be <code>null</code>).</dd>
<dd><code>previous</code> - the value returned by <code>add­Contextual­Unit(unit)</code> (can be <code>null</code>).</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">Illegal­State­Exception</a></code> - if this method has not been invoked in the pattern documented above.</dd>
<dt>Since:</dt>
<dd>0.6</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toContextualUnit(javax.measure.Unit)">
<h3>toContextualUnit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html" title="class or interface in javax.measure" class="external-link">Quantity</a>&lt;Q&gt;&gt;</span>&nbsp;<span class="return-type"><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;</span>&nbsp;<span class="element-name">toContextualUnit</span><wbr><span class="parameters">(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;Q&gt;&nbsp;unit)</span></div>
<div class="block">Returns the unit to use instead of the given one, or <code>unit</code> if there is no replacement.
 This method searches for a unit specified by <a href="#addContextualUnit(javax.measure.Unit)"><code>add­Contextual­Unit(Unit)</code></a>
 which <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html#isCompatible(javax.measure.Unit)" title="class or interface in javax.measure" class="external-link">is compatible</a> with the given unit.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>Q</code> - the quantity of the unit.</dd>
<dt>Parameters:</dt>
<dd><code>unit</code> - the unit to replace by the contextual unit, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>a contextual unit compatible with the given unit, or <code>unit</code>
         (which may be null) if no contextual unit has been found.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isInvalidWKT()">
<h3>isInvalidWKT</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isInvalidWKT</span>()</div>
<div class="block">Returns <code>true</code> if the WKT written by this formatter is not strictly compliant to the WKT specification.
 This method returns <code>true</code> if <a href="#setInvalidWKT(org.opengis.referencing.IdentifiedObject,java.lang.Exception)"><code>set­Invalid­WKT(Identified­Object, Exception)</code></a> has been invoked at
 least once. The action to take regarding invalid WKT is caller-dependent.
 For example, <a href="FormattableObject.html#toString()"><code>Formattable­Object​.to­String()</code></a> will accepts loose WKT formatting and ignore
 this flag, while <a href="FormattableObject.html#toWKT()"><code>Formattable­Object​.to­WKT()</code></a> requires strict WKT formatting and will
 thrown an exception if this flag is set.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if the WKT is invalid.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setInvalidWKT(org.opengis.referencing.IdentifiedObject,java.lang.Exception)">
<h3>setInvalidWKT</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setInvalidWKT</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link">IdentifiedObject</a>&nbsp;unformattable,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;cause)</span></div>
<div class="block">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 <a href="FormattableObject.html#formatTo(org.apache.sis.io.wkt.Formatter)"><code>Formattable­Object​.format­To(Formatter)</code></a> when the object
 to format is more complex than what the WKT specification allows.
 Applications can test <a href="#isInvalidWKT()"><code>is­Invalid­WKT()</code></a> later for checking WKT validity.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>unformattable</code> - the object that cannot be formatted,</dd>
<dd><code>cause</code> - the cause for the failure to format, or <code>null</code> if the cause is not an exception.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setInvalidWKT(java.lang.Class,java.lang.Exception)">
<h3>setInvalidWKT</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setInvalidWKT</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;unformattable,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;cause)</span></div>
<div class="block">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 <a href="#setInvalidWKT(org.opengis.referencing.IdentifiedObject,java.lang.Exception)"><code>set­Invalid­WKT(Identified­Object, Exception)</code></a> when the
 problematic object is not an instance of <code>Identified­Object</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>unformattable</code> - the class of the object that cannot be formatted,</dd>
<dd><code>cause</code> - the cause for the failure to format, or <code>null</code> if the cause is not an exception.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toWKT()">
<h3>toWKT</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toWKT</span>()</div>
<div class="block">Returns the WKT formatted by this object.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the WKT formatted by this formatter.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toString()">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span>()</div>
<div class="block">Returns a string representation of this formatter for debugging purpose.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">to­String</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></dd>
<dt>Returns:</dt>
<dd>a string representation of this formatter.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2010&#x2013;2022 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
