<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (11.0.4) on Fri Sep 20 12:10:30 CEST 2019 -->
<title>EPSGFactory (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.sql.EPSGFactory class">
<meta name="keywords" content="dataSource">
<meta name="keywords" content="nameFactory">
<meta name="keywords" content="datumFactory">
<meta name="keywords" content="csFactory">
<meta name="keywords" content="crsFactory">
<meta name="keywords" content="copFactory">
<meta name="keywords" content="mtFactory">
<meta name="keywords" content="getCodeSpaces()">
<meta name="keywords" content="getLocale()">
<meta name="keywords" content="install()">
<meta name="keywords" content="newDataAccess()">
<meta name="keywords" content="canClose()">
<meta name="keywords" content="isCacheable()">
<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="EPSGFactory (Apache SIS 1.0 API)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance 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/EPSGFactory.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><a href="#field.summary">Field</a>&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><a href="#field.detail">Field</a>&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.sql</a></div>
<h2 title="Class EPSGFactory" class="title">Class EPSGFactory</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><a href="../GeodeticAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">GeodeticAuthorityFactory</a></li>
<li>
<ul class="inheritance">
<li><a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">ConcurrentAuthorityFactory</a>&lt;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&gt;</li>
<li>
<ul class="inheritance">
<li>EPSGFactory</li>
</ul>
</li>
</ul>
</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="https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Auto­Closeable</a></code>, <code><a href="../../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></code>, <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/referencing/crs/CRSAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSAuthority­Factory</a></code>, <code><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">CSAuthority­Factory</a></code>, <code><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">Datum­Authority­Factory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">Coordinate­Operation­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>
<hr>
<pre>public class <span class="typeNameLabel">EPSGFactory</span>
extends <a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">ConcurrentAuthorityFactory</a>&lt;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&gt;
implements <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">CRSAuthorityFactory</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">CSAuthorityFactory</a>, <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">DatumAuthorityFactory</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperationAuthorityFactory</a>, <a href="../../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></pre>
<div class="block">A geodetic object factory backed by the EPSG database. This class creates JDBC connections to the EPSG database
 when first needed using the <a href="https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html?is-external=true" title="class or interface in javax.sql" class="externalLink"><code>Data­Source</code></a> specified at construction time. The geodetic objects are cached
 for reuse and the idle connections are closed after a timeout.

 <p>If no data source has been specified to the constructor, then <code>EPSGFactory</code> searches for a
 default data source in JNDI, or in the directory given by the <code>SIS_DATA</code> environment variable,
 or in the directory given by the <code>"derby​​.system​​.home"</code> property, in that order.
 See the <a href="package-summary.html">package documentation</a> for more information.</p>

 <div class="section">EPSG dataset installation</div>
 This class tries to automatically detect the schema that contains the EPSG tables
 (see <a href="SQLTranslator.html" title="class in org.apache.sis.referencing.factory.sql"><code>SQLTranslator</code></a> for examples of tables to look for). If the tables are not found,
 then the <a href="#install(java.sql.Connection)"><code>install(Connection)</code></a> method will be invoked for creating the EPSG schema.
 The <code>install(…)</code> method can perform its work only if the definition files are reachable
 on the classpath, or if the directory containing the files have been specified.

 <div class="section">Data Access Object (DAO)</div>
 If there is no cached object for a given code, then <code>EPSGFactory</code> creates an <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> instance
 for performing the actual creation work. Developers who need to customize the geodetic object creation can override
 the <a href="#newDataAccess(java.sql.Connection,org.apache.sis.referencing.factory.sql.SQLTranslator)"><code>new­Data­Access(Connection, SQLTranslator)</code></a> method in order to return their own <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a>
 subclass.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.7</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a>, 
<a href="SQLTranslator.html" title="class in org.apache.sis.referencing.factory.sql"><code>SQLTranslator</code></a>, 
<a href="http://sis.apache.org/tables/CoordinateReferenceSystems.html">List of authority codes</a></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">
<!-- =========== FIELD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Field</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperationFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#copFactory">copFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#crsFactory">crsFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#csFactory">csFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html?is-external=true" title="class or interface in javax.sql" class="externalLink">DataSource</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dataSource">dataSource</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink"><code>Connection</code></a>s to the EPSG database.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">DatumFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#datumFactory">datumFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransformFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">MathTransformFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#mtFactory">mtFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransform.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>Math­Transform</code></a> instances.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/NameFactory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">NameFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#nameFactory">nameFactory</a></span></code></th>
<td class="colLast">
<div class="block">The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/GenericName.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>Generic­Name</code></a> instances.</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ======== 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">Constructor</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E(java.util.Map)">EPSGFactory</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</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>,&#8203;?&gt;&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Creates a factory using the given configuration.</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="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>protected boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#canClose(org.apache.sis.referencing.factory.sql.EPSGDataAccess)">canClose</a></span>&#8203;(<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&nbsp;factory)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given Data Access Object (DAO) can be closed.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<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 the namespace of EPSG codes.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util" class="externalLink">Locale</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getLocale()">getLocale</a></span>()</code></th>
<td class="colLast">
<div class="block">Returns the locale used by this factory for producing error messages.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#install(java.sql.Connection)">install</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink">Connection</a>&nbsp;connection)</code></th>
<td class="colLast">
<div class="block">Creates the EPSG schema in the database and populates the tables with geodetic definitions.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>protected boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isCacheable(java.lang.String,java.lang.Object)">isCacheable</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,
           <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>&nbsp;object)</code></th>
<td class="colLast">
<div class="block">Returns whether the given object can be cached.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>protected <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newDataAccess()">newDataAccess</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates the factory which will perform the actual geodetic object creation work.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>protected <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newDataAccess(java.sql.Connection,org.apache.sis.referencing.factory.sql.SQLTranslator)">newDataAccess</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink">Connection</a>&nbsp;connection,
             <a href="SQLTranslator.html" title="class in org.apache.sis.referencing.factory.sql">SQLTranslator</a>&nbsp;translator)</code></th>
<td class="colLast">
<div class="block">Creates the factory which will perform the actual geodetic object creation from a given connection.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.ConcurrentAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">ConcurrentAuthorityFactory</a></h3>
<code><a href="../ConcurrentAuthorityFactory.html#close()">close</a>, <a href="../ConcurrentAuthorityFactory.html#createCartesianCS(java.lang.String)">create­Cartesian­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createCompoundCRS(java.lang.String)">create­Compound­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createCoordinateOperation(java.lang.String)">create­Coordinate­Operation</a>, <a href="../ConcurrentAuthorityFactory.html#createCoordinateReferenceSystem(java.lang.String)">create­Coordinate­Reference­System</a>, <a href="../ConcurrentAuthorityFactory.html#createCoordinateSystem(java.lang.String)">create­Coordinate­System</a>, <a href="../ConcurrentAuthorityFactory.html#createCoordinateSystemAxis(java.lang.String)">create­Coordinate­System­Axis</a>, <a href="../ConcurrentAuthorityFactory.html#createCylindricalCS(java.lang.String)">create­Cylindrical­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createDatum(java.lang.String)">create­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#createDerivedCRS(java.lang.String)">create­Derived­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createEllipsoid(java.lang.String)">create­Ellipsoid</a>, <a href="../ConcurrentAuthorityFactory.html#createEllipsoidalCS(java.lang.String)">create­Ellipsoidal­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createEngineeringCRS(java.lang.String)">create­Engineering­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createEngineeringDatum(java.lang.String)">create­Engineering­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#createExtent(java.lang.String)">create­Extent</a>, <a href="../ConcurrentAuthorityFactory.html#createFromCoordinateReferenceSystemCodes(java.lang.String,java.lang.String)">create­From­Coordinate­Reference­System­Codes</a>, <a href="../ConcurrentAuthorityFactory.html#createGeocentricCRS(java.lang.String)">create­Geocentric­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createGeodeticDatum(java.lang.String)">create­Geodetic­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#createGeographicCRS(java.lang.String)">create­Geographic­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createImageCRS(java.lang.String)">create­Image­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createImageDatum(java.lang.String)">create­Image­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#createObject(java.lang.String)">create­Object</a>, <a href="../ConcurrentAuthorityFactory.html#createOperationMethod(java.lang.String)">create­Operation­Method</a>, <a href="../ConcurrentAuthorityFactory.html#createParameterDescriptor(java.lang.String)">create­Parameter­Descriptor</a>, <a href="../ConcurrentAuthorityFactory.html#createPolarCS(java.lang.String)">create­Polar­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createPrimeMeridian(java.lang.String)">create­Prime­Meridian</a>, <a href="../ConcurrentAuthorityFactory.html#createProjectedCRS(java.lang.String)">create­Projected­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createSphericalCS(java.lang.String)">create­Spherical­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createTemporalCRS(java.lang.String)">create­Temporal­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createTemporalDatum(java.lang.String)">create­Temporal­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#createTimeCS(java.lang.String)">create­Time­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createUnit(java.lang.String)">create­Unit</a>, <a href="../ConcurrentAuthorityFactory.html#createVerticalCRS(java.lang.String)">create­Vertical­CRS</a>, <a href="../ConcurrentAuthorityFactory.html#createVerticalCS(java.lang.String)">create­Vertical­CS</a>, <a href="../ConcurrentAuthorityFactory.html#createVerticalDatum(java.lang.String)">create­Vertical­Datum</a>, <a href="../ConcurrentAuthorityFactory.html#getAuthority()">get­Authority</a>, <a href="../ConcurrentAuthorityFactory.html#getAuthorityCodes(java.lang.Class)">get­Authority­Codes</a>, <a href="../ConcurrentAuthorityFactory.html#getDescriptionText(java.lang.String)">get­Description­Text</a>, <a href="../ConcurrentAuthorityFactory.html#getTimeout(java.util.concurrent.TimeUnit)">get­Timeout</a>, <a href="../ConcurrentAuthorityFactory.html#newIdentifiedObjectFinder()">new­Identified­Object­Finder</a>, <a href="../ConcurrentAuthorityFactory.html#normalizeCode(java.lang.String)">normalize­Code</a>, <a href="../ConcurrentAuthorityFactory.html#printCacheContent(java.io.PrintWriter)">print­Cache­Content</a>, <a href="../ConcurrentAuthorityFactory.html#setTimeout(long,java.util.concurrent.TimeUnit)">set­Timeout</a>, <a href="../ConcurrentAuthorityFactory.html#toString()">to­String</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.GeodeticAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="../GeodeticAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">GeodeticAuthorityFactory</a></h3>
<code><a href="../GeodeticAuthorityFactory.html#createParametricCRS(java.lang.String)">create­Parametric­CRS</a>, <a href="../GeodeticAuthorityFactory.html#createParametricCS(java.lang.String)">create­Parametric­CS</a>, <a href="../GeodeticAuthorityFactory.html#createParametricDatum(java.lang.String)">create­Parametric­Datum</a>, <a href="../GeodeticAuthorityFactory.html#trimNamespace(java.lang.String)">trim­Namespace</a></code></li>
</ul>
<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#createObject(java.lang.String)" title="class or interface in org.opengis.referencing" class="externalLink">create­Object</a>, <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>, <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>, <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></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.CoordinateOperationAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperationAuthorityFactory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true#createCoordinateOperation(java.lang.String)" title="class or interface in org.opengis.referencing.operation" class="externalLink">create­Coordinate­Operation</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true#createFromCoordinateReferenceSystemCodes(java.lang.String,java.lang.String)" title="class or interface in org.opengis.referencing.operation" class="externalLink">create­From­Coordinate­Reference­System­Codes</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true#createOperationMethod(java.lang.String)" title="class or interface in org.opengis.referencing.operation" class="externalLink">create­Operation­Method</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.CRSAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<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">CRSAuthorityFactory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createCompoundCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Compound­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createCoordinateReferenceSystem(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Coordinate­Reference­System</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createDerivedCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Derived­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createEngineeringCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Engineering­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createGeocentricCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Geocentric­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createGeographicCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Geographic­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createImageCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Image­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createProjectedCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Projected­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createTemporalCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Temporal­CRS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSAuthorityFactory.html?is-external=true#createVerticalCRS(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Vertical­CRS</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.CSAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<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">CSAuthorityFactory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createCartesianCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Cartesian­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createCoordinateSystem(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Coordinate­System</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createCoordinateSystemAxis(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Coordinate­System­Axis</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createCylindricalCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Cylindrical­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createEllipsoidalCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Ellipsoidal­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createPolarCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Polar­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createSphericalCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Spherical­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createTimeCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Time­CS</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createUnit(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Unit</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSAuthorityFactory.html?is-external=true#createVerticalCS(java.lang.String)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Vertical­CS</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.DatumAuthorityFactory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<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">DatumAuthorityFactory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Datum</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createEllipsoid(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Ellipsoid</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createEngineeringDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Engineering­Datum</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createGeodeticDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Geodetic­Datum</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createImageDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Image­Datum</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createPrimeMeridian(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Prime­Meridian</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createTemporalDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Temporal­Datum</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumAuthorityFactory.html?is-external=true#createVerticalDatum(java.lang.String)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Vertical­Datum</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">
<!-- ============ FIELD DETAIL =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a id="dataSource">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>dataSource</h4>
<pre>protected final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html?is-external=true" title="class or interface in javax.sql" class="externalLink">DataSource</a> dataSource</pre>
<div class="block">The factory to use for creating <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink"><code>Connection</code></a>s to the EPSG database.</div>
</li>
</ul>
<a id="nameFactory">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>nameFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/NameFactory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">NameFactory</a> nameFactory</pre>
<div class="block">The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/GenericName.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>Generic­Name</code></a> instances.</div>
</li>
</ul>
<a id="datumFactory">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>datumFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">DatumFactory</a> datumFactory</pre>
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</li>
</ul>
<a id="csFactory">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>csFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a> csFactory</pre>
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</li>
</ul>
<a id="crsFactory">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>crsFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a> crsFactory</pre>
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</li>
</ul>
<a id="copFactory">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>copFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">CoordinateOperationFactory</a> copFactory</pre>
<div class="block">The factory to use for creating <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> instances
 from the properties read in the database.</div>
</li>
</ul>
<a id="mtFactory">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>mtFactory</h4>
<pre>protected final&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransformFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">MathTransformFactory</a> mtFactory</pre>
<div class="block">The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransform.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>Math­Transform</code></a> instances.
 The math transforms are created as part of <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>
 creation process.</div>
</li>
</ul>
</li>
</ul>
</section>
<!-- ========= 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;(java.util.Map)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>EPSGFactory</h4>
<pre>public&nbsp;EPSGFactory&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</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>,&#8203;?&gt;&nbsp;properties)
            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 factory using the given configuration. The properties recognized by this constructor
 are listed in the table below. Any property not listed below will be ignored by this constructor.
 All properties are optional and can <code>null</code> or omitted, in which case default values are used.
 Those default values are implementation-specific and may change in any future SIS version.

 <table class="sis">
  <caption>Recognized properties</caption>
  <tr>
   <th>Key</th>
   <th>Value class</th>
   <th>Description</th>
  </tr><tr>
   <td><code>dataSource</code></td>
   <td><a href="https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html?is-external=true" title="class or interface in javax.sql" class="externalLink"><code>DataSource</code></a></td>
   <td>The factory to use for creating <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink"><code>Connection</code></a>s to the EPSG database.</td>
  </tr><tr>
   <td><code>nameFactory</code></td>
   <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/NameFactory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>NameFactory</code></a></td>
   <td>The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/GenericName.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>Generic­Name</code></a> instances.</td>
  </tr><tr>
   <td><code>datumFactory</code></td>
   <td><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>DatumAuthorityFactory</code></a></td>
   <td>The factory to use for creating <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> instances.</td>
  </tr><tr>
   <td><code>csFactory</code></td>
   <td><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>CSAuthorityFactory</code></a></td>
   <td>The factory to use for creating <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> instances.</td>
  </tr><tr>
   <td><code>crsFactory</code></td>
   <td><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>CRSAuthorityFactory</code></a></td>
   <td>The factory to use for creating <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> instances.</td>
  </tr><tr>
   <td><code>copFactory</code></td>
   <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/CoordinateOperationAuthorityFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>CoordinateOperationAuthorityFactory</code></a></td>
   <td>The factory to use for creating <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> instances.</td>
  </tr><tr>
   <td><code>mtFactory</code></td>
   <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransformFactory.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>MathTransformFactory</code></a></td>
   <td>The factory to use for creating <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/MathTransform.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink"><code>Math­Transform</code></a> instances.</td>
  </tr><tr>
   <td><code>catalog</code></td>
   <td><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"><code>String</code></a></td>
   <td>The database catalog that contains the EPSG schema (see <a href="#install(java.sql.Connection)">install</a>).</td>
  </tr><tr>
   <td><code>schema</code></td>
   <td><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"><code>String</code></a></td>
   <td>The database schema that contains the EPSG tables (see <a href="#install(java.sql.Connection)">install</a>).</td>
  </tr><tr>
   <td><code>scriptProvider</code></td>
   <td><a href="InstallationScriptProvider.html" title="class in org.apache.sis.referencing.factory.sql"><code>InstallationScriptProvider</code></a></td>
   <td>A provider of SQL scripts to use if <code>EPSGFactory</code> needs to create the database.</td>
  </tr><tr>
   <td><code>locale</code></td>
   <td><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util" class="externalLink"><code>Locale</code></a></td>
   <td>The locale for producing error messages on a <cite>best effort</cite> basis.</td>
  </tr>
 </table>

 <p>Default values</p>
 <ul>
   <li>If no <code>data­Source</code> is specified, this constructor defaults to the search algorithm described
       in the <a href="package-summary.html">package documentation</a>.</li>
   <li>If no <code>catalog</code> or <code>schema</code> is specified, <a href="SQLTranslator.html" title="class in org.apache.sis.referencing.factory.sql"><code>SQLTranslator</code></a> will try to auto-detect
       the schema that contains the EPSG tables.</li>
   <li>If no <code>locale</code> is specified, this constructor defaults to the
       <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true#getDefault(java.util.Locale.Category)" title="class or interface in java.util" class="externalLink">display locale</a>.</li>
 </ul></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - the data source, authority factories and other configuration properties,
                     or <code>null</code> for the default values.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/ClassCastException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class­Cast­Exception</a></code> - if a property value is not of the expected class.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Illegal­Argument­Exception</a></code> - if a property value is invalid.</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 creating the EPSG factory.</dd>
</dl>
</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="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 the namespace of EPSG codes.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../GeodeticAuthorityFactory.html#getCodeSpaces()">get­Code­Spaces</a></code>&nbsp;in class&nbsp;<code><a href="../GeodeticAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Geodetic­Authority­Factory</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the <code>"EPSG"</code> string in a singleton map.</dd>
</dl>
</li>
</ul>
<a id="getLocale()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLocale</h4>
<pre class="methodSignature">public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util" class="externalLink">Locale</a>&nbsp;getLocale()</pre>
<div class="block">Returns the locale used by this factory for producing error messages.
 This locale does not change the way data are read from the EPSG database.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../util/Localized.html#getLocale()">get­Locale</a></code>&nbsp;in interface&nbsp;<code><a href="../../../util/Localized.html" title="interface in org.apache.sis.util">Localized</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the locale for error messages.</dd>
</dl>
</li>
</ul>
<a id="install(java.sql.Connection)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>install</h4>
<pre class="methodSignature">public&nbsp;void&nbsp;install&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink">Connection</a>&nbsp;connection)
             throws <a href="../UnavailableFactoryException.html" title="class in org.apache.sis.referencing.factory">UnavailableFactoryException</a></pre>
<div class="block">Creates the EPSG schema in the database and populates the tables with geodetic definitions.
 This method is invoked automatically when <a href="#newDataAccess()"><code>new­Data­Access()</code></a> detects that the EPSG dataset is not installed.
 Users can also invoke this method explicitly if they wish to force the dataset installation.

 <p>This method uses the following properties from the map specified at
 <a href="#%3Cinit%3E(java.util.Map)">construction time</a>:</p>

 <ul class="verbose">
   <li><b><code>catalog</code>:</b><br>
     a <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"><code>String</code></a> giving the name of the database catalog where to create the EPSG schema.
     If non-null, that catalog shall exist prior this method call (this method does not create any catalog).
     If no catalog is specified or if the catalog is an empty string,
     then the EPSG schema will be created without catalog.
     If the database does not <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/DatabaseMetaData.html?is-external=true#supportsCatalogsInTableDefinitions()" title="class or interface in java.sql" class="externalLink">support
     catalogs in table definitions</a> or in <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/DatabaseMetaData.html?is-external=true#supportsCatalogsInDataManipulation()" title="class or interface in java.sql" class="externalLink">data manipulation</a>, then this property is ignored.</li>

   <li><b><code>schema</code>:</b><br>
     a <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"><code>String</code></a> giving the name of the database schema where to create the EPSG tables.
     That schema shall <strong>not</strong> exist prior this method call;
     the schema will be created by this <code>install(…)</code> method.
     If the schema is an empty string, then the tables will be created without schema.
     If no schema is specified, then the default schema is <code>"EPSG"</code>.
     If the database does not <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/DatabaseMetaData.html?is-external=true#supportsSchemasInTableDefinitions()" title="class or interface in java.sql" class="externalLink">support
     schemas in table definitions</a> or in <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/DatabaseMetaData.html?is-external=true#supportsSchemasInDataManipulation()" title="class or interface in java.sql" class="externalLink">data manipulation</a>, then this property is ignored.</li>

   <li><b><code>script­Provider</code>:</b><br>
     an <a href="InstallationScriptProvider.html" title="class in org.apache.sis.referencing.factory.sql"><code>Installation­Script­Provider</code></a> giving the SQL scripts to execute for creating the EPSG database.
     If no provider is specified, then this method will search on the classpath (with <a href="https://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html?is-external=true" title="class or interface in java.util" class="externalLink"><code>Service­Loader</code></a>)
     for user-provided implementations of <code>Installation­Script­Provider</code>.
     If no user-specified provider is found, then this method will search for
     <code>"EPSG_*Tables​.sql"</code>, <code>"EPSG_*Data​.sql"</code> and <code>"EPSG_*FKeys​.sql"</code> files in the
     <code>$SIS_DATA/Databases/External­Sources</code> directory where <code>*</code> stands for any characters
     provided that there is no ambiguity.</li>
 </ul>

 <p><b>Legal constraint:</b>
 the EPSG dataset can not be distributed with Apache SIS at this time for licensing reasons.
 Users need to either install the dataset manually (for example with the help of this method),
 or add on the classpath to a separated bundle like <code>org​.apache​.sis:non-free:sis-epsg​.jar</code>.
 See <a href="http://sis.apache.org/epsg.html">How to use EPSG geodetic dataset</a> for more information.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>connection</code> - connection to the database where to create the EPSG schema.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../UnavailableFactoryException.html" title="class in org.apache.sis.referencing.factory">Unavailable­Factory­Exception</a></code> - if installation failed. The exception will have a
         <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io" class="externalLink"><code>File­Not­Found­Exception</code></a> cause if a SQL script has not been found
         (typically because a required resource is not on the classpath), an
         <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io" class="externalLink"><code>IOException</code></a> if an I/O error occurred while reading a SQL script, or a
         <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/SQLException.html?is-external=true" title="class or interface in java.sql" class="externalLink"><code>SQLException</code></a> if an error occurred while writing to the database.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="InstallationScriptProvider.html" title="class in org.apache.sis.referencing.factory.sql"><code>Installation­Script­Provider</code></a></dd>
</dl>
</li>
</ul>
<a id="newDataAccess()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>newDataAccess</h4>
<pre class="methodSignature">protected&nbsp;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&nbsp;newDataAccess()
                                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 the factory which will perform the actual geodetic object creation work.
 This method is invoked automatically when a new worker is required, either because the previous
 one has been disposed after its timeout or because a new one is required for concurrency.

 <p>The default implementation performs the following steps:</p>
 <ol>
   <li>Gets a new connection from the <a href="#dataSource"><code>data­Source</code></a>.</li>
   <li>If this method is invoked for the first time, verifies if the EPSG tables exists.
       If the tables are not found, invokes <a href="#install(java.sql.Connection)"><code>install(Connection)</code></a>.</li>
   <li>Delegates to <a href="#newDataAccess(java.sql.Connection,org.apache.sis.referencing.factory.sql.SQLTranslator)"><code>new­Data­Access(Connection, SQLTranslator)</code></a>, which provides an easier
       overriding point for subclasses wanting to return a custom <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> instance.</li>
 </ol></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../ConcurrentAuthorityFactory.html#newDataAccess()">new­Data­Access</a></code>&nbsp;in class&nbsp;<code><a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Concurrent­Authority­Factory</a>&lt;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGData­Access</a>&gt;</code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Data Access Object (DAO) to use in <code>create­Foo(String)</code> methods.</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 constructor failed to connect to the EPSG database.
         This exception usually has a <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/SQLException.html?is-external=true" title="class or interface in java.sql" class="externalLink"><code>SQLException</code></a> as its cause.</dd>
</dl>
</li>
</ul>
<a id="newDataAccess(java.sql.Connection,org.apache.sis.referencing.factory.sql.SQLTranslator)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>newDataAccess</h4>
<pre class="methodSignature">protected&nbsp;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&nbsp;newDataAccess&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/sql/Connection.html?is-external=true" title="class or interface in java.sql" class="externalLink">Connection</a>&nbsp;connection,
                                       <a href="SQLTranslator.html" title="class in org.apache.sis.referencing.factory.sql">SQLTranslator</a>&nbsp;translator)
                                throws <a href="https://docs.oracle.com/javase/8/docs/api/java/sql/SQLException.html?is-external=true" title="class or interface in java.sql" class="externalLink">SQLException</a></pre>
<div class="block">Creates the factory which will perform the actual geodetic object creation from a given connection.
 This method is a convenience hook easier to override than <a href="#newDataAccess()"><code>new­Data­Access()</code></a> for subclasses
 wanting to return instances of their own <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> subclass.
 The default implementation is simply:

 <blockquote><pre><font color="green">return</font> <font color="green">new</font> <b>EPSGDataAccess</b>(<font color="green">this</font>, connection, translator);</pre></blockquote>

 Subclasses can override this method with a similar code but with <code>new EPSGData­Access(…)</code> replaced
 by <code>new My­Data­Access­Subclass(…)</code>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>connection</code> - a connection to the EPSG database.</dd>
<dd><code>translator</code> - the translator from the SQL statements using MS-Access dialect to SQL statements
                     using the dialect of the actual database.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Data Access Object (DAO) to use in <code>create­Foo(String)</code> methods.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/sql/SQLException.html?is-external=true" title="class or interface in java.sql" class="externalLink">SQLException</a></code> - if a problem with the database has been detected.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="EPSGDataAccess.html#%3Cinit%3E(org.apache.sis.referencing.factory.sql.EPSGFactory,java.sql.Connection,org.apache.sis.referencing.factory.sql.SQLTranslator)"><code>EPSGData­Access(EPSGFactory, Connection, SQLTranslator)</code></a></dd>
</dl>
</li>
</ul>
<a id="canClose(org.apache.sis.referencing.factory.sql.EPSGDataAccess)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>canClose</h4>
<pre class="methodSignature">protected&nbsp;boolean&nbsp;canClose&#8203;(<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGDataAccess</a>&nbsp;factory)</pre>
<div class="block">Returns <code>true</code> if the given Data Access Object (DAO) can be closed. This method is invoked automatically
 after the <a href="../ConcurrentAuthorityFactory.html#getTimeout(java.util.concurrent.TimeUnit)">timeout</a> if the given DAO has been idle during all that time. The default
 implementation always returns <code>false</code> if a set returned by <a href="EPSGDataAccess.html#getAuthorityCodes(java.lang.Class)"><code>EPSGData­Access​.get­Authority­Codes(Class)</code></a>
 is still in use.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../ConcurrentAuthorityFactory.html#canClose(DAO)">can­Close</a></code>&nbsp;in class&nbsp;<code><a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Concurrent­Authority­Factory</a>&lt;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGData­Access</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>factory</code> - the Data Access Object which is about to be closed.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given Data Access Object can be closed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../ConcurrentAuthorityFactory.html#close()"><code>Concurrent­Authority­Factory​.close()</code></a></dd>
</dl>
</li>
</ul>
<a id="isCacheable(java.lang.String,java.lang.Object)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>isCacheable</h4>
<pre class="methodSignature">protected&nbsp;boolean&nbsp;isCacheable&#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,
                              <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>&nbsp;object)</pre>
<div class="block">Returns whether the given object can be cached.
 This method is invoked after <a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> created a new object not previously in the cache.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../ConcurrentAuthorityFactory.html#isCacheable(java.lang.String,java.lang.Object)">is­Cacheable</a></code>&nbsp;in class&nbsp;<code><a href="../ConcurrentAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">Concurrent­Authority­Factory</a>&lt;<a href="EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql">EPSGData­Access</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - the authority code specified by the caller for creating an object.</dd>
<dd><code>object</code> - the object created for the given authority code.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>whether the given object should be cached.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../ConcurrentAuthorityFactory.html#printCacheContent(java.io.PrintWriter)"><code>Concurrent­Authority­Factory​.print­Cache­Content(Print­Writer)</code></a></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/EPSGFactory.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><a href="#field.summary">Field</a>&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><a href="#field.detail">Field</a>&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>
