sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1718286 [2/2] - in /sis/branches/JDK8/core: sis-referencing/src/main/java/org/apache/sis/referencing/factory/ sis-utility/src/main/java/org/apache/sis/util/resources/
Date Mon, 07 Dec 2015 10:06:31 GMT
Added: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java?rev=1718286&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java
(added)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java
[UTF-8] Mon Dec  7 10:06:31 2015
@@ -0,0 +1,487 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.referencing.factory;
+
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.opengis.util.GenericName;
+import org.opengis.util.FactoryException;
+import org.opengis.metadata.Identifier;
+import org.opengis.metadata.citation.Citation;
+import org.opengis.referencing.IdentifiedObject;
+import org.opengis.referencing.AuthorityFactory;
+import org.opengis.referencing.NoSuchAuthorityCodeException;
+import org.apache.sis.referencing.AbstractIdentifiedObject;
+import org.apache.sis.referencing.IdentifiedObjects;
+import org.apache.sis.internal.util.Citations;
+import org.apache.sis.internal.system.Loggers;
+import org.apache.sis.util.ArgumentChecks;
+import org.apache.sis.util.ComparisonMode;
+import org.apache.sis.util.Utilities;
+import org.apache.sis.util.logging.Logging;
+
+
+/**
+ * Search in an authority factory for objects equal, ignoring metadata, to a given object.
+ * This class can be used for fetching a fully {@linkplain AbstractIdentifiedObject identified
object}
+ * from an incomplete one, for example from an object without "{@code ID[…]}" or "{@code
AUTHORITY[…]}"
+ * element in <cite>Well Known Text</cite>.
+ *
+ * <p>The steps for using {@code IdentifiedObjectFinder} are:</p>
+ * <ol>
+ *   <li>Get a new instance by calling
+ *       {@link GeodeticAuthorityFactory#createIdentifiedObjectFinder(Class)}.</li>
+ *   <li>Optionally configure that instance by calling its setter methods.</li>
+ *   <li>Perform a search by invoking the {@link #find(IdentifiedObject)} or
+ *       {@link #findIdentifier(IdentifiedObject)} methods.</li>
+ *   <li>Reuse the same {@code IdentifiedObjectFinder} instance for consecutive searches.</li>
+ * </ol>
+ *
+ * <div class="section">Thread safety</div>
+ * {@code IdentifiedObjectFinder} are <strong>not</strong> guaranteed to be thread-safe
even if the underlying factory
+ * is thread-safe. If concurrent searches are desired, then a new instance should be created
for each thread.
+ *
+ * @author  Martin Desruisseaux (IRD, Geomatys)
+ * @since   0.7
+ * @version 0.7
+ * @module
+ *
+ * @see GeodeticAuthorityFactory#createIdentifiedObjectFinder(Class)
+ * @see IdentifiedObjects#lookupIdentifier(IdentifiedObject, boolean)
+ */
+public class IdentifiedObjectFinder {
+    /**
+     * The factory to use for creating objects. This is the factory specified at construction
time.
+     * We do not put this field in public API because the factory may not be the one the
user would
+     * expect. Some of our {@link GeodeticAuthorityFactory} implementations will use a wrapper
+     * factory rather than the factory on which {@code createIdentifiedObjectFinder()} was
invoked.
+     */
+    final AuthorityFactory factory;
+
+    /**
+     * The proxy for objects creation. This is usually set at construction time.
+     * But in the particular case of {@link CachingAuthorityFactory#Finder}, this
+     * is left to {@code null} and assigned only when a backing store factory is
+     * in use.
+     *
+     * <p>If this field is initialized only when needed, then the following methods
+     * must be overridden and ensure that the initialization has been performed:</p>
+     * <ul>
+     *   <li>{@link #getAuthority()}</li>
+     *   <li>{@link #getCodeCandidates(IdentifiedObject)}</li>
+     *   <li>{@link #find(IdentifiedObject)} (see note below)</li>
+     *   <li>{@link #findIdentifier(IdentifiedObject)} (see note below)</li>
+     * </ul>
+     *
+     * Note: the {@code find(…)} methods do not need to be overridden if all other methods
+     * are overridden and the {@link #create(String, int)} method is overridden too.
+     */
+    private AuthorityFactoryProxy<?> proxy;
+
+    /**
+     * The parent finder, or {@code null} if none. This field is non-null only if this
+     * finder is wrapped by another finder like {@link CachingAuthorityFactory.Finder}.
+     */
+    private IdentifiedObjectFinder parent;
+
+    /**
+     * The comparison mode.
+     */
+    private ComparisonMode comparisonMode = ComparisonMode.IGNORE_METADATA;
+
+    /**
+     * {@code true} for performing full scans, or {@code false} otherwise.
+     */
+    private boolean fullScan = true;
+
+    /**
+     * Creates a finder using the specified factory.
+     *
+     * <div class="note"><b>Design note:</b>
+     * this constructor is protected because instances of this class should not be created
directly.
+     * Use {@link GeodeticAuthorityFactory#createIdentifiedObjectFinder(Class)} instead.</div>
+     *
+     * @param factory The factory to scan for the identified objects.
+     * @param type    The type of objects to lookup.
+     *
+     * @see GeodeticAuthorityFactory#createIdentifiedObjectFinder(Class)
+     */
+    protected IdentifiedObjectFinder(final AuthorityFactory factory,
+            final Class<? extends IdentifiedObject> type)
+    {
+        this.factory = factory;
+        proxy = AuthorityFactoryProxy.getInstance(type);
+    }
+
+    /**
+     * Returns the type of the objects to be created by the proxy instance.
+     * This method needs to be overridden by the sub-classes that do not define a proxy.
+     *
+     * @return The type of object to be created, as a GeoAPI interface.
+     */
+    Class<? extends IdentifiedObject> getObjectType() {
+        return proxy.type.asSubclass(IdentifiedObject.class);
+    }
+
+    /**
+     * Returns the authority of the factory used by this finder.
+     *
+     * @return The authority of the factory used for the searches.
+     * @throws FactoryException If an error occurred while fetching the authority.
+     */
+    public Citation getAuthority() throws FactoryException {
+        return factory.getAuthority();
+    }
+
+    /**
+     * Sets the given finder as the parent of this finder. The parent is typically a
+     * {@link CachingAuthorityFactory} which will be used by {@link #findFromParent}.
+     *
+     * @param other The new parent.
+     */
+    final void setParent(final IdentifiedObjectFinder other) {
+        parent = other;
+    }
+
+    /**
+     * Copies the configuration of the given finder. This method provides a central place
+     * where to add call to setters methods if such methods are added in a future version.
+     *
+     * <div class="section">Maintenance note</div>
+     * Adding properties to this method is not sufficient. See also the classes that override
+     * {@link #setFullScanAllowed(boolean)} - some of them may be defined in other packages.
+     */
+    final void copyConfiguration(final IdentifiedObjectFinder other) {
+        setComparisonMode (other.getComparisonMode());
+        setFullScanAllowed(other.isFullScanAllowed());
+    }
+
+    /**
+     * Returns the criterion used for determining if a candidate found by this {@code IdentifiedObjectFinder}
+     * should be considered equals to the requested object.
+     * The default value is {@link ComparisonMode#IGNORE_METADATA}.
+     *
+     * @return The criterion to use for comparing objects.
+     */
+    public ComparisonMode getComparisonMode() {
+        return comparisonMode;
+    }
+
+    /**
+     * Sets the criterion used for determining if a candidate found by this {@code IdentifiedObjectFinder}
+     * should be considered equals to the requested object.
+     *
+     * @param mode The criterion to use for comparing objects.
+     */
+    public void setComparisonMode(final ComparisonMode mode) {
+        ArgumentChecks.ensureNonNull("mode", mode);
+        comparisonMode = mode;
+    }
+
+    /**
+     * If {@code true}, an exhaustive full scan against all registered objects will be performed
(may be slow).
+     * Otherwise only a fast lookup based on embedded identifiers and names will be performed.
+     * The default value is {@code true}.
+     *
+     * @return {@code true} if exhaustive scans are allowed, or {@code false} for faster
but less complete searches.
+     */
+    public boolean isFullScanAllowed() {
+        return fullScan;
+    }
+
+    /**
+     * Sets whatever an exhaustive scan against all registered objects is allowed.
+     * The default value is {@code true}.
+     *
+     * @param fullScan {@code true} for allowing exhaustive scans,
+     *        or {@code false} for faster but less complete searches.
+     */
+    public void setFullScanAllowed(final boolean fullScan) {
+        this.fullScan = fullScan;
+    }
+
+    /**
+     * Lookups an object which is {@linkplain Utilities#equalsIgnoreMetadata equal, ignoring
metadata},
+     * to the specified object.
+     * The default implementation tries to instantiate some {@linkplain AbstractIdentifiedObject
identified objects}
+     * from the authority factory specified at construction time, in the following order:
+     *
+     * <ul>
+     *   <li>If the specified object contains {@linkplain AbstractIdentifiedObject#getIdentifiers()
identifiers}
+     *       associated to the same authority than the factory, then those identifiers are
used for
+     *       {@linkplain GeodeticAuthorityFactory#createObject creating objects} to be tested.</li>
+     *   <li>If the authority factory can create objects from their {@linkplain AbstractIdentifiedObject#getName()
name}
+     *       in addition of identifiers, then the name and {@linkplain AbstractIdentifiedObject#getAlias()
aliases} are
+     *       used for creating objects to be tested.</li>
+     *   <li>If {@linkplain #isFullScanAllowed() full scan is allowed}, then full {@linkplain
#getCodeCandidates
+     *       set of authority codes} are used for creating objects to be tested.</li>
+     * </ul>
+     *
+     * The first of the above created objects which is equal to the specified object in the
+     * the sense of {@link Utilities#equalsIgnoreMetadata(Object, Object)} is returned.
+     *
+     * @param  object The object looked up.
+     * @return The identified object, or {@code null} if not found.
+     * @throws FactoryException if an error occurred while creating an object.
+     */
+    public IdentifiedObject find(final IdentifiedObject object) throws FactoryException {
+        ArgumentChecks.ensureNonNull("object", object);
+        /*
+         * First check if one of the identifiers can be used to spot directly an
+         * identified object (and check it's actually equal to one in the factory).
+         */
+        IdentifiedObject candidate = createFromIdentifiers(object);
+        if (candidate != null) {
+            return candidate;
+        }
+        /*
+         * We are unable to find the object from its identifiers. Try a quick name lookup.
+         * Some implementations like the one backed by the EPSG database are capable to find
+         * an object from its name.
+         */
+        candidate = createFromNames(object);
+        if (candidate != null) {
+            return candidate;
+        }
+        /*
+         * Here we exhausted the quick paths. Bail out if the user does not want a full scan.
+         */
+        return fullScan ? createFromCodes(object) : null;
+    }
+
+    /**
+     * Returns the identifier of the specified object, or {@code null} if none. The default
+     * implementation invokes <code>{@linkplain #find find}(object)</code> and
extracts the
+     * code from the returned {@linkplain AbstractIdentifiedObject identified object}.
+     *
+     * @param  object The object looked up.
+     * @return The identifier of the given object, or {@code null} if none were found.
+     * @throws FactoryException if an error occurred while creating an object.
+     */
+    public String findIdentifier(final IdentifiedObject object) throws FactoryException {
+        final IdentifiedObject candidate = find(object);
+        if (candidate == null) {
+            return null;
+        }
+        final Citation authority = getAuthority();
+        Identifier identifier = IdentifiedObjects.getIdentifier(candidate, authority);
+        if (identifier == null) {
+            identifier = candidate.getName();
+        }
+        return IdentifiedObjects.toString(identifier);
+    }
+
+    /**
+     * Lookups an object from the parent finder, of from this finder if there is no parent.
+     * A parent finder exists only if this finder is wrapped by another finder. The parent
+     * can be the {@link CachingAuthorityFactory} finder or {@link AuthorityFactoryAdapter}
+     * finder.
+     *
+     * <p>This method should be considered as an implementation details.
+     * It is needed by {@link org.apache.sis.referencing.factory.epsg.EPSGFactory}.
+     * The main purpose of this method is to allow {@link DirectAuthorityFactory}
+     * implementations to look for dependencies while leveraging the cache managed
+     * by their {@link CachingAuthorityFactory} wrappers.</p>
+     *
+     * @param  object The object looked up.
+     * @param  type The type of object to look for. It does not need to be the type specified
+     *         at construction time. This relaxation exists in order to allow dependencies
lookup,
+     *         since the dependencies may be of different kinds.
+     * @return The identified object, or {@code null} if not found.
+     * @throws FactoryException if an error occurred while creating an object.
+     */
+    final IdentifiedObject findFromParent(final IdentifiedObject object,
+            final Class<? extends IdentifiedObject> type) throws FactoryException
+    {
+        return findFromParent(object, AuthorityFactoryProxy.getInstance(type));
+    }
+
+    /**
+     * Implementation of {@link #findFromParent(IdentifiedObject, Class)}, which may invoke
itself
+     * recursively.  This method delegates to the parent if there is one, but still save
and setup
+     * the proxy for this context frame. This is because {@link CachingAuthorityFactory}
delegates
+     * to {@link DirectAuthorityFactory}, which delegate back to {@link CachingAuthorityFactory}
+     * through this method (for object dependencies lookup), etc.
+     */
+    private IdentifiedObject findFromParent(final IdentifiedObject object,
+            final AuthorityFactoryProxy<?> type) throws FactoryException
+    {
+        final IdentifiedObjectFinder parent = this.parent;
+        final AuthorityFactoryProxy<?> old = proxy;
+        proxy = type;
+        try {
+            return (parent != null) ? parent.findFromParent(object, type) : find(object);
+        } finally {
+            proxy = old;
+        }
+    }
+
+    /**
+     * Creates an object {@linkplain Utilities#equalsIgnoreMetadata equal, ignoring metadata},
to the
+     * specified object using only the {@linkplain AbstractIdentifiedObject#getIdentifiers
identifiers}.
+     * If no such object is found, returns {@code null}.
+     *
+     * <p>This method may be used in order to get a fully identified object from a
partially identified one.</p>
+     *
+     * @param  object The object looked up.
+     * @return The identified object, or {@code null} if not found.
+     * @throws FactoryException if an error occurred while creating an object.
+     *
+     * @see #createFromCodes(IdentifiedObject)
+     * @see #createFromNames(IdentifiedObject)
+     */
+    final IdentifiedObject createFromIdentifiers(final IdentifiedObject object) throws FactoryException
{
+        final Citation authority = getAuthority();
+        for (final Identifier id : object.getIdentifiers()) {
+            if (!Citations.identifierMatches(authority, id.getAuthority())) {
+                // The identifier is not for this authority. Looks the other ones.
+                continue;
+            }
+            final String code = IdentifiedObjects.toString(id);
+            final IdentifiedObject candidate;
+            try {
+                candidate = (IdentifiedObject) proxy.createFromAPI(factory, code);
+            } catch (NoSuchAuthorityCodeException e) {
+                // The identifier was not recognized. No problem, let's go on.
+                continue;
+            }
+            if (Utilities.deepEquals(candidate, object, comparisonMode)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Creates an object {@linkplain Utilities#equalsIgnoreMetadata equal, ignoring metadata},
to
+     * the specified object using only the {@linkplain AbstractIdentifiedObject#getName name}
and
+     * {@linkplain AbstractIdentifiedObject#getAlias aliases}. If no such object is found,
returns
+     * {@code null}.
+     *
+     * <p>This method may be used with some {@linkplain GeodeticAuthorityFactory authority
factory}
+     * implementations like the one backed by the EPSG database, which are capable to find
an object
+     * from its name when the identifier is unknown.</p>
+     *
+     * @param  object The object looked up.
+     * @return The identified object, or {@code null} if not found.
+     * @throws FactoryException if an error occurred while creating an object.
+     *
+     * @see #createFromCodes(IdentifiedObject)
+     * @see #createFromIdentifiers(IdentifiedObject)
+     */
+    final IdentifiedObject createFromNames(final IdentifiedObject object) throws FactoryException
{
+        String code = object.getName().getCode();
+        IdentifiedObject candidate;
+        try {
+            candidate = (IdentifiedObject) proxy.createFromAPI(factory, code);
+        } catch (FactoryException e) {
+            /*
+             * The identifier was not recognized. We will continue later will aliases.
+             * Note: we catch a more generic exception than NoSuchAuthorityCodeException
because
+             *       this attempt may fail for various reasons (character string not supported
+             *       by the underlying database for primary key, duplicated name found, etc.).
+             */
+            candidate = null;
+        }
+        if (Utilities.deepEquals(candidate, object, comparisonMode)) {
+            return candidate;
+        }
+        for (final GenericName id : object.getAlias()) {
+            code = id.toString();
+            try {
+                candidate = (IdentifiedObject) proxy.createFromAPI(factory, code);
+            } catch (FactoryException e) {
+                // The name was not recognized. No problem, let's go on.
+                continue;
+            }
+            if (Utilities.deepEquals(candidate, object, comparisonMode)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Creates an object {@linkplain Utilities#equalsIgnoreMetadata equal, ignoring metadata},
to the
+     * specified object. This method scans the {@linkplain #getAuthorityCodes authority codes},
+     * create the objects and returns the first one which is equal to the specified object
in
+     * the sense of {@link Utilities#equalsIgnoreMetadata equalsIgnoreMetadata}.
+     *
+     * <p>This method may be used in order to get a fully {@linkplain AbstractIdentifiedObject
identified
+     * object} from an object without {@linkplain AbstractIdentifiedObject#getIdentifiers()
identifiers}.</p>
+     *
+     * <p>Scanning the whole set of authority codes may be slow. Users should try
+     * <code>{@linkplain #createFromIdentifiers createFromIdentifiers}(object)</code>
and/or
+     * <code>{@linkplain #createFromNames createFromNames}(object)</code> before
to fallback
+     * on this method.</p>
+     *
+     * @param  object The object looked up.
+     * @return The identified object, or {@code null} if not found.
+     * @throws FactoryException if an error occurred while scanning through authority codes.
+     *
+     * @see #createFromIdentifiers(IdentifiedObject)
+     * @see #createFromNames(IdentifiedObject)
+     */
+    final IdentifiedObject createFromCodes(final IdentifiedObject object) throws FactoryException
{
+        final Set<String> codes = getCodeCandidates(object);
+        if (!codes.isEmpty()) {
+            for (final String code : codes) {
+                final IdentifiedObject candidate;
+                try {
+                    candidate = (IdentifiedObject) proxy.createFromAPI(factory, code);
+                } catch (FactoryException e) {
+                    continue;
+                }
+                if (Utilities.deepEquals(candidate, object, comparisonMode)) {
+                    return candidate;
+                }
+            }
+            final Logger logger = Logging.getLogger(Loggers.CRS_FACTORY);
+            logger.log(Level.FINEST, "No match found for “{0}” among {1}",
+                    new Object[] {object.getName(), codes});
+        }
+        return null;
+    }
+
+    /**
+     * Returns a set of authority codes that <strong>may</strong> identify the
same object than the specified one.
+     * The returned set must contains <em>at least</em> the code of every objects
that are
+     * {@linkplain Utilities#equalsIgnoreMetadata equal, ignoring metadata}, to the specified
one.
+     * However the set is not required to contains only the codes of those objects;
+     * it may conservatively contains the code for more objects if an exact search is too
expensive.
+     *
+     * <p>This method is invoked by the default {@link #find(IdentifiedObject)} method
implementation.
+     * The caller iterates through the returned codes, instantiate the objects and compare
them with
+     * the specified one in order to determine which codes are really applicable.
+     * The iteration stops as soon as a match is found (in other words, if more than one
object is equals
+     * to the specified one, then the {@code find(…)} method selects the first one in iteration
order).</p>
+     *
+     * <div class="section">Default implementation</div>
+     * The default implementation returns the same set than
+     * <code>{@linkplain GeodeticAuthorityFactory#getAuthorityCodes(Class) getAuthorityCodes}(type)</code>
+     * where {@code type} is the interface specified at construction type.
+     * Subclasses should override this method in order to return a smaller set, if they can.
+     *
+     * @param  object The object looked up.
+     * @return A set of code candidates.
+     * @throws FactoryException if an error occurred while fetching the set of code candidates.
+     */
+    protected Set<String> getCodeCandidates(final IdentifiedObject object) throws FactoryException
{
+        return factory.getAuthorityCodes(getObjectType());
+    }
+}

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/IdentifiedObjectFinder.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java?rev=1718286&r1=1718285&r2=1718286&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
[UTF-8] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.java
[UTF-8] Mon Dec  7 10:06:31 2015
@@ -281,6 +281,11 @@ public final class Errors extends Indexe
         public static final short ExcessiveStringSize = 153;
 
         /**
+         * No factory of kind ‘{0}’ found.
+         */
+        public static final short FactoryNotFound_1 = 205;
+
+        /**
          * File “{0}” has not been found.
          */
         public static final short FileNotFound_1 = 166;

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties?rev=1718286&r1=1718285&r2=1718286&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
[ISO-8859-1] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors.properties
[ISO-8859-1] Mon Dec  7 10:06:31 2015
@@ -67,6 +67,7 @@ ExcessiveArgumentSize_3           = Argu
 ExcessiveListSize_2               = A size of {1} elements is excessive for the \u201c{0}\u201d
list.
 ExcessiveNumberOfDimensions_1     = For this algorithm, {0} is an excessive number of dimensions.
 ExcessiveStringSize               = The character string is too long.
+FactoryNotFound_1                 = No factory of kind \u2018{0}\u2019 found.
 FileNotFound_1                    = File \u201c{0}\u201d has not been found.
 ForbiddenAttribute_2              = Attribute \u201c{0}\u201d is not allowed for an object
of type \u2018{1}\u2019.
 ForbiddenProperty_1               = Property \u201c{0}\u201d is not allowed.

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties?rev=1718286&r1=1718285&r2=1718286&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
[ISO-8859-1] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Errors_fr.properties
[ISO-8859-1] Mon Dec  7 10:06:31 2015
@@ -64,6 +64,7 @@ ExcessiveArgumentSize_3           = L\u2
 ExcessiveListSize_2               = Une taille de {1} \u00e9l\u00e9ments est excessive pour
la liste \u00ab\u202f{0}\u202f\u00bb.
 ExcessiveNumberOfDimensions_1     = Pour cet algorithme, {0} est un trop grand nombre de
dimensions.
 ExcessiveStringSize               = La cha\u00eene de caract\u00e8res est trop longue.
+FactoryNotFound_1                 = Aucune fabrique de type \u2018{0}\u2019 n\u2019a \u00e9t\u00e9
trouv\u00e9e.
 FileNotFound_1                    = Le fichier \u00ab\u202f{0}\u202f\u00bb n\u2019a pas \u00e9t\u00e9
trouv\u00e9.
 ForbiddenAttribute_2              = L\u2019attribut \u00ab\u202f{0}\u202f\u00bb n\u2019est
pas autoris\u00e9 pour un objet de type \u2018{1}\u2019.
 ForbiddenProperty_1               = La propri\u00e9t\u00e9 \u00ab\u202f{0}\u202f\u00bb n\u2019est
pas autoris\u00e9e.



Mime
View raw message