<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (11.0.4) on Fri Sep 20 12:10:30 CEST 2019 -->
<title>GeodeticAuthorityFactory (Apache SIS 1.0 API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="dc.created" content="2019-09-20">
<meta name="keywords" content="org.apache.sis.referencing.factory.GeodeticAuthorityFactory class">
<meta name="keywords" content="getAuthority()">
<meta name="keywords" content="getCodeSpaces()">
<meta name="keywords" content="getDescriptionText()">
<meta name="keywords" content="createObject()">
<meta name="keywords" content="createCoordinateReferenceSystem()">
<meta name="keywords" content="createGeographicCRS()">
<meta name="keywords" content="createGeocentricCRS()">
<meta name="keywords" content="createProjectedCRS()">
<meta name="keywords" content="createVerticalCRS()">
<meta name="keywords" content="createTemporalCRS()">
<meta name="keywords" content="createParametricCRS()">
<meta name="keywords" content="createCompoundCRS()">
<meta name="keywords" content="createDerivedCRS()">
<meta name="keywords" content="createEngineeringCRS()">
<meta name="keywords" content="createImageCRS()">
<meta name="keywords" content="createDatum()">
<meta name="keywords" content="createGeodeticDatum()">
<meta name="keywords" content="createVerticalDatum()">
<meta name="keywords" content="createTemporalDatum()">
<meta name="keywords" content="createParametricDatum()">
<meta name="keywords" content="createEngineeringDatum()">
<meta name="keywords" content="createImageDatum()">
<meta name="keywords" content="createEllipsoid()">
<meta name="keywords" content="createPrimeMeridian()">
<meta name="keywords" content="createExtent()">
<meta name="keywords" content="createCoordinateSystem()">
<meta name="keywords" content="createEllipsoidalCS()">
<meta name="keywords" content="createVerticalCS()">
<meta name="keywords" content="createTimeCS()">
<meta name="keywords" content="createParametricCS()">
<meta name="keywords" content="createCartesianCS()">
<meta name="keywords" content="createSphericalCS()">
<meta name="keywords" content="createCylindricalCS()">
<meta name="keywords" content="createPolarCS()">
<meta name="keywords" content="createCoordinateSystemAxis()">
<meta name="keywords" content="createUnit()">
<meta name="keywords" content="createParameterDescriptor()">
<meta name="keywords" content="createOperationMethod()">
<meta name="keywords" content="createCoordinateOperation()">
<meta name="keywords" content="createFromCoordinateReferenceSystemCodes()">
<meta name="keywords" content="newIdentifiedObjectFinder()">
<meta name="keywords" content="trimNamespace()">
<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="../../../../../jquery/jquery-ui.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../jquery/jquery-3.3.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-migrate-3.0.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-ui.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="GeodeticAuthorityFactory (Apache SIS 1.0 API)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":6,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10,"i28":10,"i29":10,"i30":10,"i31":10,"i32":10,"i33":10,"i34":10,"i35":10,"i36":10,"i37":6,"i38":10,"i39":10,"i40":10,"i41":10,"i42":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],4:["t3","Abstract Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../";
var useModuleDirectories = false;
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<header role="banner">
<nav role="navigation">
<div class="fixedNav">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/GeodeticAuthorityFactory.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">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<ul class="navListSearch">
<li><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<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="subNavList">
<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>
<a id="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
</div>
<div class="navPadding">&nbsp;</div>
<script type="text/javascript"><!--
$('.navPadding').css('padding-top', $('.fixedNav').css("height"));
//-->
</script>
</nav>
</header>
<!-- ======== START OF CLASS DATA ======== -->
<main role="main">
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.referencing.factory</a></div>
<h2 title="Class GeodeticAuthorityFactory" class="title">Class GeodeticAuthorityFactory</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></li>
<li>
<ul class="inheritance">
<li><a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a></li>
<li>
<ul class="inheritance">
<li>GeodeticAuthorityFactory</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">Authority­Factory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory</a></code></dd>
</dl>
<dl>
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="CommonAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Common­Authority­Factory</a></code>, <code><a href="ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Concurrent­Authority­Factory</a></code>, <code><a href="sql/EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGData­Access</a></code>, <code><a href="MultiAuthoritiesFactory.html" title="class in org.apache.sis.referencing.factory">Multi­Authorities­Factory</a></code></dd>
</dl>
<hr>
<pre>public abstract class <span class="typeNameLabel">GeodeticAuthorityFactory</span>
extends <a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a>
implements <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">AuthorityFactory</a></pre>
<div class="block">Creates geodetic objects from codes defined by an authority.
 An <cite>authority</cite> is an organization that maintains definitions of authority codes.
 An <cite>authority code</cite> is a compact string defined by an authority to reference a particular spatial reference object.
 A frequently used set of authority codes is the <a href="http://www.epsg.org">EPSG geodetic dataset</a>,
 a database of coordinate systems and other spatial referencing objects where each object has a code number ID.

 <div class="note"><b>Example:</b>
 the EPSG code for a <cite>World Geodetic System 1984</cite> (WGS84) coordinate reference system
 with latitude and longitude axes is <code>"4326"</code>.</div>

 <p>This class defines a default implementation for most methods defined in the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink"><code>Datum­Authority­Factory</code></a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>CSAuthority­Factory</code></a> and <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>CRSAuthority­Factory</code></a> interfaces. However, those interfaces do not appear
 in the <code>implements</code> clause of this class declaration. This is up to subclasses to decide which interfaces
 they declare to implement.</p>

 <p>The default implementation for all <code>create­Foo(String)</code> methods ultimately invokes
 <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a>, which may be the only method that a subclass need to override.
 However, other methods may be overridden as well for better performances.</p></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.7</dd>

<p><font size="-1">Defined in the <code>sis-referencing</code> module</font></p>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier</th>
<th class="colSecond" scope="col">Constructor</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected </code></td>
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E()">GeodeticAuthorityFactory</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a new authority factory for geodetic objects.</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ========== METHOD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t3" class="tableTab"><span><a href="javascript:show(4);">Abstract Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCartesianCS(java.lang.String)">createCartesianCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2- or 3-dimensional Cartesian coordinate system made of straight orthogonal axes.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CompoundCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CompoundCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCompoundCRS(java.lang.String)">createCompoundCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a CRS describing the position of points through two or more independent coordinate reference systems.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperation.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperation</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCoordinateOperation(java.lang.String)">createCoordinateOperation</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates an operation for transforming coordinates in the source CRS to coordinates in the target CRS.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCoordinateReferenceSystem(java.lang.String)">createCoordinateReferenceSystem</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates an arbitrary coordinate reference system from a code.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCoordinateSystem(java.lang.String)">createCoordinateSystem</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates an arbitrary coordinate system from a code.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCoordinateSystemAxis(java.lang.String)">createCoordinateSystemAxis</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a coordinate system axis with name, direction, unit and range of values.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CylindricalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CylindricalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCylindricalCS(java.lang.String)">createCylindricalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 3-dimensional coordinate system made of a polar coordinate system
 extended by a straight perpendicular axis.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Datum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createDatum(java.lang.String)">createDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates an arbitrary datum from a code.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/DerivedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">DerivedCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createDerivedCRS(java.lang.String)">createDerivedCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a CRS that is defined by its coordinate conversion from another CRS (not by a datum).</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEllipsoid(java.lang.String)">createEllipsoid</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a geometric figure that can be used to describe the approximate shape of the earth.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEllipsoidalCS(java.lang.String)">createEllipsoidalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2- or 3-dimensional coordinate system for geodetic latitude and longitude,
 sometime with ellipsoidal height.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/EngineeringCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">EngineeringCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEngineeringCRS(java.lang.String)">createEngineeringCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-, 2- or 3-dimensional contextually local coordinate reference system.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEngineeringDatum(java.lang.String)">createEngineeringDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum defining the origin of an engineering coordinate reference system.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/extent/Extent.html?is-external=true" title="class or interface in org.opengis.metadata.extent" class="externalLink">Extent</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createExtent(java.lang.String)">createExtent</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates information about spatial, vertical, and temporal extent (usually a domain of validity) from a code.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util" class="externalLink">Set</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperation.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperation</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createFromCoordinateReferenceSystemCodes(java.lang.String,java.lang.String)">createFromCoordinateReferenceSystemCodes</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;sourceCRS,
                                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;targetCRS)</code></th>
<td class="colLast">
<div class="block">Creates operations from source and target coordinate reference system codes.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeocentricCRS(java.lang.String)">createGeocentricCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 3-dimensional coordinate reference system with the origin at the approximate centre of mass of the earth.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeodeticDatum(java.lang.String)">createGeodeticDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum defining the location and orientation of an ellipsoid that approximates the shape of the earth.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeographicCRS(java.lang.String)">createGeographicCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2- or 3-dimensional coordinate reference system based on an ellipsoidal approximation of the geoid.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ImageCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ImageCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createImageCRS(java.lang.String)">createImageCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2-dimensional engineering coordinate reference system applied to locations in images.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createImageDatum(java.lang.String)">createImageDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum defining the origin of an image coordinate reference system.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>abstract <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">IdentifiedObject</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createObject(java.lang.String)">createObject</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Returns an arbitrary object from a code.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/OperationMethod.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">OperationMethod</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createOperationMethod(java.lang.String)">createOperationMethod</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a description of the algorithm and parameters used to perform a coordinate operation.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/parameter/ParameterDescriptor.html?is-external=true" title="class or interface in org.opengis.parameter" class="externalLink">ParameterDescriptor</a>&lt;?&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParameterDescriptor(java.lang.String)">createParameterDescriptor</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a definition of a single parameter used by an operation method.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs">DefaultParametricCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricCRS(java.lang.String)">createParametricCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional parametric coordinate reference system.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricCS(java.lang.String)">createParametricCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional parametric coordinate system.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricDatum(java.lang.String)">createParametricDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum defining the origin of a parametric coordinate reference system.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/PolarCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">PolarCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createPolarCS(java.lang.String)">createPolarCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2-dimensional coordinate system for coordinates represented by a distance from the origin
 and an angle from a fixed direction.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createPrimeMeridian(java.lang.String)">createPrimeMeridian</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a prime meridian defining the origin from which longitude values are determined.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ProjectedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ProjectedCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createProjectedCRS(java.lang.String)">createProjectedCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 2-dimensional coordinate reference system used to approximate the shape of the earth on a planar surface.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createSphericalCS(java.lang.String)">createSphericalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 3-dimensional coordinate system with one distance measured from the origin and two angular coordinates.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/TemporalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">TemporalCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTemporalCRS(java.lang.String)">createTemporalCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional coordinate reference system used for the recording of time.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTemporalDatum(java.lang.String)">createTemporalDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum defining the origin of a temporal coordinate reference system.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTimeCS(java.lang.String)">createTimeCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional coordinate system for time elapsed in the specified time units
 from a specified time origin.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createUnit(java.lang.String)">createUnit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates an unit of measurement from a code.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">VerticalCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalCRS(java.lang.String)">createVerticalCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional coordinate reference system used for recording heights or depths.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalCS(java.lang.String)">createVerticalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a 1-dimensional coordinate system for heights or depths of points.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalDatum(java.lang.String)">createVerticalDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Creates a datum identifying a particular reference level surface used as a zero-height surface.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>abstract <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/citation/Citation.html?is-external=true" title="class or interface in org.opengis.metadata.citation" class="externalLink">Citation</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getAuthority()">getAuthority</a></span>()</code></th>
<td class="colLast">
<div class="block">Returns the database or specification that defines the codes recognized by this factory.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util" class="externalLink">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getCodeSpaces()">getCodeSpaces</a></span>()</code></th>
<td class="colLast">
<div class="block">Returns all namespaces recognized by this factory.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">InternationalString</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getDescriptionText(java.lang.String)">getDescriptionText</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Returns a description of the object corresponding to a code.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code><a href="IdentifiedObjectFinder.html" title="class in org.apache.sis.referencing.factory">IdentifiedObjectFinder</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newIdentifiedObjectFinder()">newIdentifiedObjectFinder</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a finder which can be used for looking up unidentified objects.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#toString()">toString</a></span>()</code></th>
<td class="colLast">
<div class="block">Returns a string representation of this factory for debugging purpose only.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#trimNamespace(java.lang.String)">trimNamespace</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Trims the namespace, if present.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.AbstractFactory">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a></h3>
<code><a href="../../util/iso/AbstractFactory.html#getVendor()">get­Vendor</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang" class="externalLink">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang" class="externalLink">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang" class="externalLink">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang" class="externalLink">get­Class</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang" class="externalLink">hash­Code</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang" class="externalLink">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang" class="externalLink">notify­All</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long,int)" title="class or interface in java.lang" class="externalLink">wait</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.AuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">AuthorityFactory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">get­Authority­Codes</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.Factory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true#getVendor()" title="class or interface in org.opengis.util" class="externalLink">get­Vendor</a></code></li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a id="&lt;init&gt;()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>GeodeticAuthorityFactory</h4>
<pre>protected&nbsp;GeodeticAuthorityFactory()</pre>
<div class="block">Creates a new authority factory for geodetic objects.</div>
</li>
</ul>
</li>
</ul>
</section>
<!-- ============ METHOD DETAIL ========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a id="getAuthority()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAuthority</h4>
<pre class="methodSignature">public abstract&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/citation/Citation.html?is-external=true" title="class or interface in org.opengis.metadata.citation" class="externalLink">Citation</a>&nbsp;getAuthority()</pre>
<div class="block">Returns the database or specification that defines the codes recognized by this factory.
 This method may return <code>null</code> if it can not obtain this information, for example because
 the connection to a database is not available.

 <div class="note"><b>Example:</b>
 a factory that create coordinate reference system objects from EPSG codes could return
 a citation like below:

 <blockquote><pre>Citation
├─ Title ……………………………………………………… EPSG Geodetic Parameter Dataset
├─ Identifier ………………………………………… EPSG
├─ Online resource (1 of 2)
│  ├─ Linkage ………………………………………… http://epsg-registry.org/
│  └─ Function ……………………………………… Browse
└─ Online resource (2 of 2)
   ├─ Linkage ………………………………………… jdbc:derby:/my/path/to/SIS_DATA/Databases/SpatialMetadata
   ├─ Description ……………………………… EPSG dataset version 9.1 on “Apache Derby Embedded JDBC Driver” version 10.14.
   └─ Function ……………………………………… Connection</pre></blockquote>

 The online resource description with a “Connection” function is a SIS extension.</div></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthority()" title="class or interface in org.opengis.referencing" class="externalLink">get­Authority</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">Authority­Factory</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the organization responsible for definition of the database, or <code>null</code> if unknown.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../util/iso/AbstractFactory.html#getVendor()"><code>Abstract­Factory​.get­Vendor()</code></a></dd>
</dl>
</li>
</ul>
<a id="getCodeSpaces()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getCodeSpaces</h4>
<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util" class="externalLink">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&gt;&nbsp;getCodeSpaces()</pre>
<div class="block">Returns all namespaces recognized by this factory. Those namespaces can appear before codes in
 calls to <code>create­Foo(String)</code> methods, for example <code>"EPSG"</code> in <code>"EPSG:4326"</code>.
 Namespaces are case-insensitive.

 <p>The namespaces are closely related to the <a href="#getAuthority()">authority</a>. Often the namespace is
 the authority <a href="../../metadata/iso/citation/DefaultCitation.html#getIdentifiers()">identifier</a>,
 but not always.</p>

 <div class="note"><b>Examples:</b>
 <ul class="verbose">
   <li>The <a href="sql/EPSGFactory.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGFactory</code></a> authority identifier is <code>"EPSG"</code>
       and its <code>get­Code­Spaces()</code> method returns a set containing <code>"EPSG"</code>. So in this example,
       authority and namespace match. That namespace value means that <code>EPSGFactory​.create­Foo(String)</code>
       methods accept both <code>"EPSG:4326"</code> (case-insensitive) and <code>"4326"</code> codes as argument.</li>

   <li>The <a href="sql/EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> authority identifier is <code>"EPSG"</code>
       but its <code>get­Code­Spaces()</code> method returns an empty set. This means that despite the EPSG authority,
       <code>EPSGData­Access​.create­Foo(String)</code> methods accept only codes like <code>"4326"</code> without
       <code>"EPSG:"</code> prefix (the reason is that <code>EPSGData­Access</code> is not expected to be used directly).</li>

   <li>The <a href="CommonAuthorityFactory.html" title="class in org.apache.sis.referencing.factory"><code>Common­Authority­Factory</code></a> authority identifiers are ISO 19128 and OGC 06-042 (the WMS specification)
       but its <code>get­Code­Spaces()</code> method returns a set containing <code>"CRS"</code>, <code>"AUTO"</code> and <code>"AUTO2"</code>.
       While ISO 19128 is defined as the first authority, the namespace is actually defined by OGC.</li>
 </ul></div>

 The default implementation infers the namespace from the <a href="#getAuthority()">authority</a>.
 Subclasses can override this method, but the set should always contain the same elements during
 all factory lifetime.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the namespaces recognized by this factory, or an empty set if none.</dd>
</dl>
</li>
</ul>
<a id="getDescriptionText(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getDescriptionText</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">InternationalString</a>&nbsp;getDescriptionText&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                       throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Returns a description of the object corresponding to a code.
 The description can be used for example in a combo box in a graphical user interface.

 <div class="section">Default implementation</div>
 The default implementation invokes <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> for the given code
 and returns the <a href="../AbstractIdentifiedObject.html#getName()">object name</a>.
 This may be costly since it involves a full object creation.
 Subclasses are encouraged to provide a more efficient implementation if they can.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getDescriptionText(java.lang.String)" title="class or interface in org.opengis.referencing" class="externalLink">get­Description­Text</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">Authority­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a description of the object, or <code>null</code> if the object
         corresponding to the specified <code>code</code> has no description.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if an error occurred while fetching the description.</dd>
</dl>
</li>
</ul>
<a id="createObject(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createObject</h4>
<pre class="methodSignature">public abstract&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">IdentifiedObject</a>&nbsp;createObject&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                       throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Returns an arbitrary object from a code. The returned object will typically be an instance of <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Datum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink"><code>Datum</code></a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Coordinate­System</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Coordinate­Reference­System</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperation.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>Coordinate­Operation</code></a>.
 This method may be used when the type of the object to create is unknown.
 But it is recommended to invoke the most specific <code>create­Foo(String)</code> method when
 the desired type is known, both for performance reason and for avoiding ambiguity.

 <div class="section">Note for subclasses</div>
 In default <code>Geodetic­Authority­Factory</code> implementation, all <code>create­Foo(String)</code> methods ultimately
 delegate to this <code>create­Object(String)</code> method and verify if the created object is of the desired type.
 Overriding this method is sufficient for supporting the more specific <code>create­Foo(String)</code> methods,
 but subclasses are encouraged to override the later for efficiency.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#createObject(java.lang.String)" title="class or interface in org.opengis.referencing" class="externalLink">create­Object</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">Authority­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the object for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing"><code>Abstract­Identified­Object</code></a></dd>
</dl>
</li>
</ul>
<a id="createCoordinateReferenceSystem(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCoordinateReferenceSystem</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>&nbsp;createCoordinateReferenceSystem&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                                          throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an arbitrary coordinate reference system from a code.
 The returned object will typically be an instance of <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Geographic­CRS</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ProjectedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Projected­CRS</code></a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Vertical­CRS</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CompoundCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Compound­CRS</code></a>.
 If the coordinate reference system type is known at compile time,
 it is recommended to invoke the most precise method instead of this one (for example
 <a href="#createGeographicCRS(java.lang.String)"><code>create­Geographic­CRS(String)</code></a> instead of
 <code>create­Coordinate­Reference­System(code)</code> if the caller know he is asking for a
 <a href="../crs/DefaultGeographicCRS.html" title="class in org.apache.sis.referencing.crs">geographic coordinate reference system</a>).

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 Two frequently used authorities are "CRS" and "EPSG", which include the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>       <th>Type</th>         <th>Description</th></tr>
   <tr><td>CRS:84</td>     <td>Geographic</td>   <td>Like EPSG:4326 except for (<var>longitude</var>, <var>latitude</var>) axis order</td></tr>
   <tr><td>EPSG:4326</td> <td>Geographic</td>    <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:4979</td> <td>Geographic 3D</td> <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:4978</td> <td>Geocentric</td>    <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:3395</td> <td>Projected</td>     <td>WGS 84 / World Mercator</td></tr>
   <tr><td>EPSG:5714</td> <td>Vertical</td>      <td>Mean Sea Level height</td></tr>
   <tr><td>EPSG:6349</td> <td>Compound</td>      <td>NAD83(2011) + NAVD88 height</td></tr>
   <tr><td>EPSG:5800</td> <td>Engineering</td>   <td>Astra Minas Grid</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/AbstractCRS.html" title="class in org.apache.sis.referencing.crs"><code>Abstract­CRS</code></a>, 
<a href="../CRS.html#forCode(java.lang.String)"><code>CRS​.for­Code(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeographicCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeographicCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a>&nbsp;createGeographicCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2- or 3-dimensional coordinate reference system based on an ellipsoidal approximation of the geoid.
 This provides an accurate representation of the geometry of geographic features
 for a large portion of the earth's surface.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 Two frequently used authorities are "CRS" and "EPSG", which include the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Type</th>          <th>Description</th></tr>
   <tr><td>CRS:27</td>    <td>Geographic</td>    <td>Like EPSG:4267 except for (<var>longitude</var>, <var>latitude</var>) axis order</td></tr>
   <tr><td>CRS:83</td>    <td>Geographic</td>    <td>Like EPSG:4269 except for (<var>longitude</var>, <var>latitude</var>) axis order</td></tr>
   <tr><td>CRS:84</td>    <td>Geographic</td>    <td>Like EPSG:4326 except for (<var>longitude</var>, <var>latitude</var>) axis order</td></tr>
   <tr><td>EPSG:4322</td> <td>Geographic</td>    <td>World Geodetic System 1972</td></tr>
   <tr><td>EPSG:4985</td> <td>Geographic 3D</td> <td>World Geodetic System 1972</td></tr>
   <tr><td>EPSG:4326</td> <td>Geographic</td>    <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:4979</td> <td>Geographic 3D</td> <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:4267</td> <td>Geographic</td>    <td>North American Datum 1927</td></tr>
   <tr><td>EPSG:4269</td> <td>Geographic</td>    <td>North American Datum 1983</td></tr>
   <tr><td>EPSG:4230</td> <td>Geographic</td>    <td>European Datum 1950</td></tr>
   <tr><td>EPSG:4258</td> <td>Geographic</td>    <td>European Terrestrial Reference Frame 1989</td></tr>
   <tr><td>EPSG:4937</td> <td>Geographic 3D</td> <td>European Terrestrial Reference Frame 1989</td></tr>
   <tr><td>EPSG:4047</td> <td>Geographic</td>    <td>GRS 1980 Authalic Sphere</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultGeographicCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Geographic­CRS</code></a>, 
<a href="../CommonCRS.html#geographic()"><code>Common­CRS​.geographic()</code></a>, 
<a href="../CommonCRS.html#geographic3D()"><code>Common­CRS​.geographic3D()</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeocentricCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeocentricCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a>&nbsp;createGeocentricCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 3-dimensional coordinate reference system with the origin at the approximate centre of mass of the earth.
 A geocentric CRS deals with the earth's curvature by taking a 3-dimensional spatial view, which obviates
 the need to model the earth's curvature.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:4936</td> <td>European Terrestrial Reference Frame 1989</td></tr>
   <tr><td>EPSG:4978</td> <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:4984</td> <td>World Geodetic System 1972</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultGeocentricCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Geocentric­CRS</code></a>, 
<a href="../CommonCRS.html#geocentric()"><code>Common­CRS​.geocentric()</code></a></dd>
</dl>
</li>
</ul>
<a id="createProjectedCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createProjectedCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ProjectedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ProjectedCRS</a>&nbsp;createProjectedCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2-dimensional coordinate reference system used to approximate the shape of the earth on a planar surface.
 It is done in such a way that the distortion that is inherent to the approximation is carefully controlled and known.
 Distortion correction is commonly applied to calculated bearings and distances to produce values
 that are a close match to actual field values.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which contains more than 4000 codes for projected CRS.
 Some of them are:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:3034</td> <td>ETRS89 / Lambert Conic Conformal Europe</td></tr>
   <tr><td>EPSG:3395</td> <td>WGS 84 / World Mercator</td></tr>
   <tr><td>EPSG:6350</td> <td>NAD83(2011) / Conus Albers Equal Area</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultProjectedCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Projected­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">VerticalCRS</a>&nbsp;createVerticalCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional coordinate reference system used for recording heights or depths.
 Vertical CRSs make use of the direction of gravity to define the concept of height or depth,
 but the relationship with gravity may not be straightforward.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:5715</td> <td>Mean Sea Level depth</td></tr>
   <tr><td>EPSG:5714</td> <td>Mean Sea Level height</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultVerticalCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Vertical­CRS</code></a>, 
<a href="../CommonCRS.Vertical.html#crs()"><code>Common­CRS​.Vertical​.crs()</code></a></dd>
</dl>
</li>
</ul>
<a id="createTemporalCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTemporalCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/TemporalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">TemporalCRS</a>&nbsp;createTemporalCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional coordinate reference system used for the recording of time.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultTemporalCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Temporal­CRS</code></a>, 
<a href="../CommonCRS.Temporal.html#crs()"><code>Common­CRS​.Temporal​.crs()</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs">DefaultParametricCRS</a>&nbsp;createParametricCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                         throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional parametric coordinate reference system.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.

 <div class="warning"><b>Warning:</b> in a future SIS version, the return type may be changed
 to <code>org​.opengis​.referencing​.crs​.Parametric­CRS</code>. This change is pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Parametric­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createCompoundCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCompoundCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CompoundCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CompoundCRS</a>&nbsp;createCompoundCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a CRS describing the position of points through two or more independent coordinate reference systems.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:6349</td> <td>NAD83(2011) + NAVD88 height</td></tr>
   <tr><td>EPSG:7423</td> <td>ETRS89 + EVRF2007 height</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultCompoundCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Compound­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createDerivedCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createDerivedCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/DerivedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">DerivedCRS</a>&nbsp;createDerivedCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a CRS that is defined by its coordinate conversion from another CRS (not by a datum).
 <code>Derived­CRS</code> can not be <code>Projected­CRS</code> themselves, but may be derived from a projected CRS.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultDerivedCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Derived­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createEngineeringCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEngineeringCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/EngineeringCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">EngineeringCRS</a>&nbsp;createEngineeringCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                    throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-, 2- or 3-dimensional contextually local coordinate reference system.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:5800</td> <td>Astra Minas Grid</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultEngineeringCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Engineering­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createImageCRS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createImageCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ImageCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ImageCRS</a>&nbsp;createImageCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2-dimensional engineering coordinate reference system applied to locations in images.
 Image coordinate reference systems are treated as a separate sub-type because a separate
 user community exists for images with its own terms of reference.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateReferenceSystem(java.lang.String)"><code>create­Coordinate­Reference­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate reference system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultImageCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Image­CRS</code></a></dd>
</dl>
</li>
</ul>
<a id="createDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Datum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum</a>&nbsp;createDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an arbitrary datum from a code. The returned object will typically be an
 instance of <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink"><code>Geodetic­Datum</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink"><code>Vertical­Datum</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink"><code>Temporal­Datum</code></a>.
 If the datum is known at compile time, it is recommended to invoke the most precise method instead of this one.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which contains hundred of datum. Some of them are:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Type</th>        <th>Description</th></tr>
   <tr><td>EPSG:6326</td> <td>Geodetic</td>    <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:6322</td> <td>Geodetic</td>    <td>World Geodetic System 1972</td></tr>
   <tr><td>EPSG:1027</td> <td>Vertical</td>    <td>EGM2008 geoid</td></tr>
   <tr><td>EPSG:5100</td> <td>Vertical</td>    <td>Mean Sea Level</td></tr>
   <tr><td>EPSG:9315</td> <td>Engineering</td> <td>Seismic bin grid datum</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/AbstractDatum.html" title="class in org.apache.sis.referencing.datum"><code>Abstract­Datum</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeodeticDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeodeticDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;createGeodeticDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum defining the location and orientation of an ellipsoid that approximates the shape of the earth.
 Geodetic datum are used together with ellipsoidal coordinate system, and also with Cartesian coordinate system
 centered in the ellipsoid (or sphere).

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which contains hundred of datum. Some of them are:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:6326</td> <td>World Geodetic System 1984</td></tr>
   <tr><td>EPSG:6322</td> <td>World Geodetic System 1972</td></tr>
   <tr><td>EPSG:6269</td> <td>North American Datum 1983</td></tr>
   <tr><td>EPSG:6258</td> <td>European Terrestrial Reference System 1989</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultGeodeticDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Geodetic­Datum</code></a>, 
<a href="../CommonCRS.html#datum()"><code>Common­CRS​.datum()</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a>&nbsp;createVerticalDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum identifying a particular reference level surface used as a zero-height surface.
 There are several types of vertical datums, and each may place constraints on the axis with which
 it is combined to create a vertical CRS.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:5100</td> <td>Mean Sea Level</td></tr>
   <tr><td>EPSG:1027</td> <td>EGM2008 geoid</td></tr>
   <tr><td>EPSG:1131</td> <td>Japanese Geodetic Datum 2011 (vertical)</td></tr>
   <tr><td>EPSG:5215</td> <td>European Vertical Reference Frame 2007</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultVerticalDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Vertical­Datum</code></a>, 
<a href="../CommonCRS.Vertical.html#datum()"><code>Common­CRS​.Vertical​.datum()</code></a></dd>
</dl>
</li>
</ul>
<a id="createTemporalDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTemporalDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a>&nbsp;createTemporalDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum defining the origin of a temporal coordinate reference system.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultTemporalDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Temporal­Datum</code></a>, 
<a href="../CommonCRS.Temporal.html#datum()"><code>Common­CRS​.Temporal​.datum()</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a>&nbsp;createParametricDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                             throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                    <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum defining the origin of a parametric coordinate reference system.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.

 <div class="warning"><b>Warning:</b> in a future SIS version, the return type may be changed
 to <code>org​.opengis​.referencing​.datum​.Parametric­Datum</code>. This change is pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Parametric­Datum</code></a></dd>
</dl>
</li>
</ul>
<a id="createEngineeringDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEngineeringDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a>&nbsp;createEngineeringDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum defining the origin of an engineering coordinate reference system.
 An engineering datum is used in a region around that origin.
 This origin can be fixed with respect to the earth or be a defined point on a moving vehicle.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:9315</td> <td>Seismic bin grid datum</td></tr>
   <tr><td>EPSG:9300</td> <td>Astra Minas</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultEngineeringDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Engineering­Datum</code></a></dd>
</dl>
</li>
</ul>
<a id="createImageDatum(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createImageDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a>&nbsp;createImageDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a datum defining the origin of an image coordinate reference system.
 An image datum is used in a local context only.
 For an image datum, the anchor point is usually either the centre of the image or the corner of the image.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createDatum(java.lang.String)"><code>create­Datum(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the datum for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultImageDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Image­Datum</code></a></dd>
</dl>
</li>
</ul>
<a id="createEllipsoid(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEllipsoid</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a>&nbsp;createEllipsoid&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                          throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a geometric figure that can be used to describe the approximate shape of the earth.
 In mathematical terms, it is a surface formed by the rotation of an ellipse about its minor axis.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:7030</td> <td>WGS 84</td></tr>
   <tr><td>EPSG:7034</td> <td>Clarke 1880</td></tr>
   <tr><td>EPSG:7048</td> <td>GRS 1980 Authalic Sphere</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ellipsoid for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultEllipsoid.html" title="class in org.apache.sis.referencing.datum"><code>Default­Ellipsoid</code></a>, 
<a href="../CommonCRS.html#ellipsoid()"><code>Common­CRS​.ellipsoid()</code></a></dd>
</dl>
</li>
</ul>
<a id="createPrimeMeridian(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPrimeMeridian</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a>&nbsp;createPrimeMeridian&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a prime meridian defining the origin from which longitude values are determined.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:8901</td> <td>Greenwich</td></tr>
   <tr><td>EPSG:8903</td> <td>Paris</td></tr>
   <tr><td>EPSG:8904</td> <td>Bogota</td></tr>
   <tr><td>EPSG:8905</td> <td>Madrid</td></tr>
   <tr><td>EPSG:8906</td> <td>Rome</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the prime meridian for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultPrimeMeridian.html" title="class in org.apache.sis.referencing.datum"><code>Default­Prime­Meridian</code></a>, 
<a href="../CommonCRS.html#primeMeridian()"><code>Common­CRS​.prime­Meridian()</code></a></dd>
</dl>
</li>
</ul>
<a id="createExtent(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createExtent</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/extent/Extent.html?is-external=true" title="class or interface in org.opengis.metadata.extent" class="externalLink">Extent</a>&nbsp;createExtent&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                    throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates information about spatial, vertical, and temporal extent (usually a domain of validity) from a code.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:1262</td> <td>World</td></tr>
   <tr><td>EPSG:3391</td> <td>World - between 80°S and 84°N</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the extent for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../metadata/iso/extent/DefaultExtent.html" title="class in org.apache.sis.metadata.iso.extent"><code>Default­Extent</code></a></dd>
</dl>
</li>
</ul>
<a id="createCoordinateSystem(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCoordinateSystem</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a>&nbsp;createCoordinateSystem&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an arbitrary coordinate system from a code. The returned object will typically be an
 instance of <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Ellipsoidal­CS</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Cartesian­CS</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Vertical­CS</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Time­CS</code></a>.
 If the coordinate system is known at compile time, it is recommended to invoke the most precise
 method instead of this one.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Type</th>              <th>Axes</th>                                    <th>Orientations</th>    <th>Unit</th></tr>
   <tr><td>EPSG:4496</td> <td>Cartesian 2D CS</td>   <td>easting, northing (E,N)</td>                 <td>east, north</td>     <td>metre</td></tr>
   <tr><td>EPSG:6422</td> <td>Ellipsoidal 2D CS</td> <td>latitude, longitude</td>                     <td>north, east</td>     <td>degree</td></tr>
   <tr><td>EPSG:6423</td> <td>Ellipsoidal 3D CS</td> <td>latitude, longitude, ellipsoidal height</td> <td>north, east, up</td> <td>degree, degree, metre</td></tr>
   <tr><td>EPSG:6404</td> <td>Spherical 3D CS</td>   <td>latitude, longitude, radius</td>             <td>north, east, up</td> <td>degree, degree, metre</td></tr>
   <tr><td>EPSG:6499</td> <td>Vertical CS</td>       <td>height (H)</td>                              <td>up</td>              <td>metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/AbstractCS.html" title="class in org.apache.sis.referencing.cs"><code>Abstract­CS</code></a>, 
<a href="../cs/CoordinateSystems.html#getEpsgCode(javax.measure.Unit,org.opengis.referencing.cs.AxisDirection...)"><code>Coordinate­Systems​.get­Epsg­Code(Unit, Axis­Direction...)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEllipsoidalCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEllipsoidalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a>&nbsp;createEllipsoidalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2- or 3-dimensional coordinate system for geodetic latitude and longitude,
 sometime with ellipsoidal height.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Axes</th>                                    <th>Orientations</th>    <th>Unit</th></tr>
   <tr><td>EPSG:6422</td> <td>latitude, longitude</td>                     <td>north, east</td>     <td>degree</td></tr>
   <tr><td>EPSG:6424</td> <td>longitude, latitude</td>                     <td>east, north</td>     <td>degree</td></tr>
   <tr><td>EPSG:6429</td> <td>longitude, latitude</td>                     <td>east, north</td>     <td>radian</td></tr>
   <tr><td>EPSG:6423</td> <td>latitude, longitude, ellipsoidal height</td> <td>north, east, up</td> <td>degree, degree, metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultEllipsoidalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Ellipsoidal­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a>&nbsp;createVerticalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional coordinate system for heights or depths of points.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Axes</th>       <th>Orientations</th> <th>Unit</th></tr>
   <tr><td>EPSG:6498</td> <td>depth (D)</td>  <td>down</td>         <td>metre</td></tr>
   <tr><td>EPSG:6499</td> <td>height (H)</td> <td>up</td>           <td>metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultVerticalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Vertical­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createTimeCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTimeCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a>&nbsp;createTimeCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                    throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional coordinate system for time elapsed in the specified time units
 from a specified time origin.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultTimeCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Time­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricCS</h4>
<pre class="methodSignature">public&nbsp;<a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a>&nbsp;createParametricCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                       throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 1-dimensional parametric coordinate system.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.

 <div class="warning"><b>Warning:</b> in a future SIS version, the return type may be changed
 to <code>org​.opengis​.referencing​.cs​.Parametric­CS</code>. This change is pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Parametric­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createCartesianCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCartesianCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;createCartesianCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2- or 3-dimensional Cartesian coordinate system made of straight orthogonal axes.
 All axes shall have the same linear unit of measure.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Axes</th>                    <th>Orientations</th> <th>Unit</th></tr>
   <tr><td>EPSG:4406</td> <td>easting, northing (E,N)</td> <td>east, north</td>  <td>kilometre</td></tr>
   <tr><td>EPSG:4496</td> <td>easting, northing (E,N)</td> <td>east, north</td>  <td>metre</td></tr>
   <tr><td>EPSG:4500</td> <td>northing, easting (N,E)</td> <td>north, east</td>  <td>metre</td></tr>
   <tr><td>EPSG:4491</td> <td>westing, northing (W,N)</td> <td>west, north</td>  <td>metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCartesianCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Cartesian­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createSphericalCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSphericalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a>&nbsp;createSphericalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 3-dimensional coordinate system with one distance measured from the origin and two angular coordinates.
 Not to be confused with an ellipsoidal coordinate system based on an ellipsoid "degenerated" into a sphere.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Axes</th>                        <th>Orientations</th>    <th>Unit</th></tr>
   <tr><td>EPSG:6404</td> <td>latitude, longitude, radius</td> <td>north, east, up</td> <td>degree, degree, metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultSphericalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Spherical­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createCylindricalCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCylindricalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CylindricalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CylindricalCS</a>&nbsp;createCylindricalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 3-dimensional coordinate system made of a polar coordinate system
 extended by a straight perpendicular axis.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCylindricalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Cylindrical­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createPolarCS(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPolarCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/PolarCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">PolarCS</a>&nbsp;createPolarCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                      throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a 2-dimensional coordinate system for coordinates represented by a distance from the origin
 and an angle from a fixed direction.

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createCoordinateSystem(java.lang.String)"><code>create­Coordinate­System(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the coordinate system for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultPolarCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Polar­CS</code></a></dd>
</dl>
</li>
</ul>
<a id="createCoordinateSystemAxis(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCoordinateSystemAxis</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;createCoordinateSystemAxis&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                                throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a coordinate system axis with name, direction, unit and range of values.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th>   <th>Unit</th></tr>
   <tr><td>EPSG:106</td>  <td>Latitude (φ)</td>  <td>degree</td></tr>
   <tr><td>EPSG:107</td>  <td>Longitude (λ)</td> <td>degree</td></tr>
   <tr><td>EPSG:1</td>    <td>Easting (E)</td>   <td>metre</td></tr>
   <tr><td>EPSG:2</td>    <td>Northing (N)</td>  <td>metre</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the axis for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCoordinateSystemAxis.html" title="class in org.apache.sis.referencing.cs"><code>Default­Coordinate­System­Axis</code></a></dd>
</dl>
</li>
</ul>
<a id="createUnit(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createUnit</h4>
<pre class="methodSignature">public&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;createUnit&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                   throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                          <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an unit of measurement from a code.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:9002</td> <td>decimal degree</td></tr>
   <tr><td>EPSG:9001</td> <td>metre</td></tr>
   <tr><td>EPSG:9030</td> <td>kilometre</td></tr>
   <tr><td>EPSG:1040</td> <td>second</td></tr>
   <tr><td>EPSG:1029</td> <td>year</td></tr>
 </table>

 See <a href="../../measure/Units.html#valueOfEPSG(int)"><code>Units​.value­Of­EPSG(int)</code></a> for a more complete list of codes.</div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the unit of measurement for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../measure/Units.html#valueOfEPSG(int)"><code>Units​.value­Of­EPSG(int)</code></a></dd>
</dl>
</li>
</ul>
<a id="createParameterDescriptor(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParameterDescriptor</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/parameter/ParameterDescriptor.html?is-external=true" title="class or interface in org.opengis.parameter" class="externalLink">ParameterDescriptor</a>&lt;?&gt;&nbsp;createParameterDescriptor&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                                 throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                        <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a definition of a single parameter used by an operation method.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:8801</td> <td>Latitude of natural origin</td></tr>
   <tr><td>EPSG:8802</td> <td>Longitude of natural origin</td></tr>
   <tr><td>EPSG:8805</td> <td>Scale factor at natural origin</td></tr>
   <tr><td>EPSG:8806</td> <td>False easting</td></tr>
   <tr><td>EPSG:8807</td> <td>False northing</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the parameter descriptor for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../parameter/DefaultParameterDescriptor.html" title="class in org.apache.sis.parameter"><code>Default­Parameter­Descriptor</code></a>, 
<a href="http://sis.apache.org/tables/CoordinateOperationMethods.html">Apache SIS™ Coordinate Operation Methods</a></dd>
</dl>
</li>
</ul>
<a id="createOperationMethod(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createOperationMethod</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/OperationMethod.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">OperationMethod</a>&nbsp;createOperationMethod&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                      throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a description of the algorithm and parameters used to perform a coordinate operation.
 An <code>Operation­Method</code> is a kind of metadata: it does not perform any coordinate operation
 (e.g. map projection) by itself, but tells us what is needed in order to perform such operation.

 <p>Available methods depend both on the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set declared by the authority</a> and on the
 <a href="http://sis.apache.org/tables/CoordinateOperationMethods.html">list of methods implemented in Apache SIS</a>.
 In order to be supported, an operation method must have its formulas coded in the Java programming language.
 See <a href="../operation/transform/MathTransformProvider.html" title="interface in org.apache.sis.referencing.operation.transform"><code>Math­Transform­Provider</code></a> for more information.</p>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the operation method for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../operation/DefaultOperationMethod.html" title="class in org.apache.sis.referencing.operation"><code>Default­Operation­Method</code></a>, 
<a href="http://sis.apache.org/tables/CoordinateOperationMethods.html">Apache SIS™ Coordinate Operation Methods</a></dd>
</dl>
</li>
</ul>
<a id="createCoordinateOperation(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCoordinateOperation</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperation.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperation</a>&nbsp;createCoordinateOperation&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)
                                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an operation for transforming coordinates in the source CRS to coordinates in the target CRS.
 Coordinate operations contain a <a href="../operation/transform/AbstractMathTransform.html" title="class in org.apache.sis.referencing.operation.transform">math transform</a>, which does the actual work of transforming coordinates.

 <div class="note"><b>Example:</b>
 the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/AuthorityFactory.html?is-external=true#getAuthorityCodes(java.lang.Class)" title="class or interface in org.opengis.referencing" class="externalLink">set of available codes</a> depends on the defining
 <a href="#getAuthority()">authority</a> and the <code>Geodetic­Authority­Factory</code> subclass in use.
 A frequently used authority is "EPSG", which includes the following codes:

 <table class="sis">
 <caption>Authority codes examples</caption>
   <tr><th>Code</th>      <th>Description</th></tr>
   <tr><td>EPSG:1133</td> <td>ED50 to WGS 84 (1)</td></tr>
   <tr><td>EPSG:1241</td> <td>NAD27 to NAD83 (1)</td></tr>
   <tr><td>EPSG:1173</td> <td>NAD27 to WGS 84 (4)</td></tr>
   <tr><td>EPSG:6326</td> <td>NAD83(2011) to NAVD88 height (1)</td></tr>
 </table></div>

 <div class="section">Default implementation</div>
 The default implementation delegates to <a href="#createObject(java.lang.String)"><code>create­Object(String)</code></a> and casts the result.
 If the result can not be casted, then a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink"><code>No­Such­Authority­Code­Exception</code></a> is thrown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - value allocated by authority.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the operation for the given code.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if the specified <code>code</code> was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../operation/AbstractCoordinateOperation.html" title="class in org.apache.sis.referencing.operation"><code>Abstract­Coordinate­Operation</code></a></dd>
</dl>
</li>
</ul>
<a id="createFromCoordinateReferenceSystemCodes(java.lang.String,java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createFromCoordinateReferenceSystemCodes</h4>
<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util" class="externalLink">Set</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperation.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperation</a>&gt;&nbsp;createFromCoordinateReferenceSystemCodes&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;sourceCRS,
                                                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;targetCRS)
                                                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">NoSuchAuthorityCodeException</a>,
                                                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates operations from source and target coordinate reference system codes.
 This method should only extract the information explicitly declared in a database like EPSG.
 This method should not attempt to infer by itself operations that are not explicitly recorded in the database.

 <div class="section">Default implementation</div>
 The default implementation returns an empty set.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>source­CRS</code> - coded value of source coordinate reference system.</dd>
<dd><code>target­CRS</code> - coded value of target coordinate reference system.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the operations from <code>source­CRS</code> to <code>target­CRS</code>.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/NoSuchAuthorityCodeException.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">No­Such­Authority­Code­Exception</a></code> - if a specified code was not found.</dd>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed for some other reason.</dd>
</dl>
</li>
</ul>
<a id="newIdentifiedObjectFinder()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>newIdentifiedObjectFinder</h4>
<pre class="methodSignature">public&nbsp;<a href="IdentifiedObjectFinder.html" title="class in org.apache.sis.referencing.factory">IdentifiedObjectFinder</a>&nbsp;newIdentifiedObjectFinder()
                                                 throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a finder which can be used for looking up unidentified objects.
 The finder tries to fetch a fully <a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">identified object</a>
 from an incomplete one, for example from an object without "<code>ID[…]</code>" or
 "<code>AUTHORITY[…]</code>" element in <cite>Well Known Text</cite>.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a finder to use for looking up unidentified objects.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the finder can not be created.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../IdentifiedObjects.html#newFinder(java.lang.String)"><code>Identified­Objects​.new­Finder(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="trimNamespace(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trimNamespace</h4>
<pre class="methodSignature">protected final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;trimNamespace&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;code)</pre>
<div class="block">Trims the namespace, if present. For example if this factory is an EPSG authority factory
 and the specified code start with the <code>"EPSG:"</code> prefix, then the prefix is removed.
 Otherwise, the string is returned unchanged (except for leading and trailing spaces).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - the code to trim.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the code with the namespace part removed if that part matched one of the values given by
         <a href="#getCodeSpaces()"><code>get­Code­Spaces()</code></a>.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="toString()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>toString</h4>
<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;toString()</pre>
<div class="block">Returns a string representation of this factory for debugging purpose only.
 The string returned by this method may change in any future SIS version.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">to­String</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a string representation for debugging purpose.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
</div>
</main>
<!-- ========= END OF CLASS DATA ========= -->
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/GeodeticAuthorityFactory.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">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<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="subNavList">
<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>
<a id="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &#169; 2010&#x2013;2019 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</body>
</html>
