sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1738832 - in /sis/branches/JDK8/core: sis-referencing/src/main/java/org/apache/sis/internal/referencing/ sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/ sis-referencing/src/main/java/org/apache/sis/referencing/f...
Date Tue, 12 Apr 2016 17:13:26 GMT
Author: desruisseaux
Date: Tue Apr 12 17:13:26 2016
New Revision: 1738832

URL: http://svn.apache.org/viewvc?rev=1738832&view=rev
Log:
Debug and add test for the case where CoordinateOperationRegistry searches for the inverse operation.

Added:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/SignReversalComment.java   (with props)
Modified:
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ReferencingUtilities.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/AbstractProvider.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
    sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/InverseOperationMethod.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/ReferencingUtilitiesTest.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/factory/sql/EPSGDataFormatter.java
    sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationRegistryTest.java
    sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.java
    sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.properties
    sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages_fr.properties

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ReferencingUtilities.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ReferencingUtilities.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ReferencingUtilities.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/ReferencingUtilities.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -247,9 +247,16 @@ public final class ReferencingUtilities
     /**
      * Returns the properties of the given object but potentially with a modified name.
      * Current implement truncates the name at the first non-white character which is not
-     * a valid Unicode identifier part.
+     * a valid Unicode identifier part, with the following exception:
+     *
+     * <ul>
+     *   <li>If the character is {@code '('} and the content until the closing {@code ')'} is a valid
+     *       Unicode identifier, then that part is included. The intend is to keep the prime meridian
+     *       name in names like <cite>"NTF (Paris)"</cite>.</li>
+     * </ul>
      *
      * <div class="note"><b>Example:</b><ul>
+     *   <li><cite>"NTF (Paris)"</cite> is left unchanged.</li>
      *   <li><cite>"WGS 84 (3D)"</cite> is truncated as <cite>"WGS 84"</cite>.</li>
      *   <li><cite>"Ellipsoidal 2D CS. Axes: latitude, longitude. Orientations: north, east. UoM: degree"</cite>
      *       is truncated as <cite>"Ellipsoidal 2D CS"</cite>.</li>
@@ -272,6 +279,15 @@ public final class ReferencingUtilities
                 for (int i=0; i < name.length();) {
                     final int c = name.codePointAt(i);
                     if (!Character.isUnicodeIdentifierPart(c) && !Character.isSpaceChar(c)) {
+                        if (c == '(') {
+                            final int endAt = name.indexOf(')', i);
+                            if (endAt >= 0) {
+                                final String extra = name.substring(i+1, endAt);
+                                if (CharSequences.isUnicodeIdentifier(extra)) {
+                                    i += extra.length() + 2;
+                                }
+                            }
+                        }
                         name = CharSequences.trimWhitespaces(name, 0, i).toString();
                         if (!name.isEmpty()) {
                             final Map<String,Object> copy = new HashMap<>(properties);

Added: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/SignReversalComment.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/SignReversalComment.java?rev=1738832&view=auto
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/SignReversalComment.java (added)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/SignReversalComment.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -0,0 +1,87 @@
+/*
+ * 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.internal.referencing;
+
+import java.util.Locale;
+import java.io.Serializable;
+import java.io.ObjectStreamException;
+import org.apache.sis.util.iso.AbstractInternationalString;
+import org.apache.sis.util.resources.Messages;
+
+
+/**
+ * Comments telling whether a parameter value use the same sign or the opposite sign for the inverse operation.
+ * Those comments are used for encoding the {@code PARAM_SIGN_REVERSAL} boolean value in the
+ * {@code [Coordinate_Operation Parameter Usage]} table of the EPSG dataset.
+ *
+ * <p>This approach may change in any future SIS version.</p>
+ *
+ * @author  Martin Desruisseaux (Geomatys)
+ * @since   0.7
+ * @version 0.7
+ * @module
+ *
+ * @see org.apache.sis.internal.referencing.provider.AbstractProvider#isInvertible()
+ */
+public final class SignReversalComment extends AbstractInternationalString implements Serializable {
+    /**
+     * For cross-version compatibility.
+     */
+    private static final long serialVersionUID = -2171813880302865442L;
+
+    /**
+     * Remark telling that an inverse operation uses the same sign for the parameter value.
+     */
+    public static final SignReversalComment SAME = new SignReversalComment(false);
+
+    /**
+     * Remark telling that an inverse operation uses the parameter value with opposite sign.
+     */
+    public static final SignReversalComment OPPOSITE = new SignReversalComment(true);
+
+    /**
+     * Whether the inverse operation use a parameter value of opposite sign or same sign.
+     */
+    private final boolean opposite;
+
+    /**
+     * Constructor for the {@link #SAME} and {@link #OPPOSITE} constants only.
+     */
+    private SignReversalComment(final boolean r) {
+        opposite = r;
+    }
+
+    /**
+     * Returns a human-readable text for this constant.
+     *
+     * @param  locale  the desired locale, or {@code null}.
+     * @return a human-readable text in the given locale if possible.
+     */
+    @Override
+    public String toString(final Locale locale) {
+        return Messages.getResources(locale).getString(opposite
+                ? Messages.Keys.InverseOperationUsesOppositeSign
+                : Messages.Keys.InverseOperationUsesSameSign);
+    }
+
+    /**
+     * Invokes on deserialization for returning the canonical constant.
+     */
+    private Object readResolve() throws ObjectStreamException {
+        return opposite ? OPPOSITE : SAME;
+    }
+}

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

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

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/AbstractProvider.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/AbstractProvider.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/AbstractProvider.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/internal/referencing/provider/AbstractProvider.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -219,7 +219,24 @@ public abstract class AbstractProvider e
      * Returns {@code true} if the inverse of this operation method is the same operation method with some parameter
      * values changed (typically with sign inverted). The default implementation returns {@code false}.
      *
+     * <p>This is a SIS-specific information which may be changed in any future SIS version.
+     * Current implementation provides this information in a "all or nothing" way: either all parameter values
+     * can have their sign reversed, or either the operation is considered not revertible at all.
+     * This is different than the EPSG dataset in two way:</p>
+     *
+     * <ul class="verbose">
+     *   <li>EPSG provides an equivalent information in the {@code PARAM_SIGN_REVERSAL} column of the
+     *       {@code [Coordinate_Operation Parameter Usage]} table, but on a parameter-by-parameter basis
+     *       instead than for the whole operation (which is probably better).</li>
+     *
+     *   <li>EPSG provides another information in the {@code REVERSE_OP} column of the
+     *       {@code [Coordinate_Operation Method]} table, but this is not equivalent to this method because it
+     *       does not differentiate the map projection methods from <em>inverse</em> map projection methods.</li>
+     * </ul>
+     *
      * @return {@code true} if the inverse of this operation method can be described by the same operation method.
+     *
+     * @see org.apache.sis.internal.referencing.SignReversalComment
      */
     public boolean isInvertible() {
         return false;

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/factory/sql/EPSGDataAccess.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -72,6 +72,7 @@ import org.apache.sis.internal.metadata.
 import org.apache.sis.internal.referencing.DeprecatedCode;
 import org.apache.sis.internal.referencing.EPSGParameterDomain;
 import org.apache.sis.internal.referencing.ReferencingUtilities;
+import org.apache.sis.internal.referencing.SignReversalComment;
 import org.apache.sis.internal.referencing.Formulas;
 import org.apache.sis.internal.system.Loggers;
 import org.apache.sis.internal.system.Semaphores;
@@ -1053,13 +1054,13 @@ addURIs:    for (int i=0; ; i++) {
      * @param  table       The table on which a query has been executed.
      * @param  name        The name for the {@link IndentifiedObject} to construct.
      * @param  code        The EPSG code of the object to construct.
-     * @param  remarks     Remarks, or {@code null} if none.
+     * @param  remarks     Remarks as a {@link String} or {@link InternationalString}, or {@code null} if none.
      * @param  deprecated  {@code true} if the object to create is deprecated.
      * @return The name together with a set of properties.
      */
     @SuppressWarnings("ReturnOfCollectionOrArrayField")
     private Map<String,Object> createProperties(final String table, String name, final Integer code,
-            String remarks, final boolean deprecated) throws SQLException, FactoryDataException
+            CharSequence remarks, final boolean deprecated) throws SQLException, FactoryDataException
     {
         /*
          * Search for aliases. Note that searching for the object code is not sufficient. We also need to check if the
@@ -2457,10 +2458,10 @@ addURIs:    for (int i=0; ; i++) {
                 " WHERE PARAMETER_CODE = ?", code))
         {
             while (result.next()) {
-                final Integer epsg       = getInteger  (code, result, 1);
-                final String  name       = getString   (code, result, 2);
-                final String  remarks    = getOptionalString (result, 3);
-                final boolean deprecated = getOptionalBoolean(result, 4);
+                final Integer epsg        = getInteger  (code, result, 1);
+                final String  name        = getString   (code, result, 2);
+                final String  description = getOptionalString (result, 3);
+                final boolean deprecated  = getOptionalBoolean(result, 4);
                 Class<?> type = Double.class;
                 /*
                  * If the parameter appears to have at least one non-null value in the "Parameter File Name" column,
@@ -2507,6 +2508,27 @@ next:               while (r.next()) {
                     }
                 }
                 /*
+                 * Determines if the inverse operation can be performed by reversing the parameter sign.
+                 * The EPSG dataset uses "Yes" or "No" value, but SIS scripts use boolean type. We have
+                 * to accept both.
+                 */
+                InternationalString isReversible = null;
+                try (ResultSet r = executeQuery("ParameterSign",
+                        "SELECT DISTINCT PARAM_SIGN_REVERSAL FROM [Coordinate_Operation Parameter Usage]" +
+                        " WHERE (PARAMETER_CODE = ?)", epsg))
+                {
+                    if (r.next()) {
+                        final String v = r.getString(1);
+                        if (v != null && !r.next()) {
+                            if (v.equalsIgnoreCase("true") || v.equalsIgnoreCase("yes") || v.equals("1")) {
+                                isReversible = SignReversalComment.OPPOSITE;
+                            } else if (v.equalsIgnoreCase("false") || v.equalsIgnoreCase("no") || v.equals("0")) {
+                                isReversible = SignReversalComment.SAME;
+                            }
+                        }
+                    }
+                }
+                /*
                  * Now creates the parameter descriptor.
                  */
                 final NumberRange<?> valueDomain;
@@ -2516,8 +2538,10 @@ next:               while (r.next()) {
                     case 1:  valueDomain = MeasurementRange.create(Double.NEGATIVE_INFINITY, false,
                                     Double.POSITIVE_INFINITY, false, CollectionsExt.first(units)); break;
                 }
-                final ParameterDescriptor<?> descriptor = new DefaultParameterDescriptor<>(
-                        createProperties("Coordinate_Operation Parameter", name, epsg, remarks, deprecated),
+                final Map<String, Object> properties =
+                        createProperties("Coordinate_Operation Parameter", name, epsg, isReversible, deprecated);
+                properties.put(Identifier.DESCRIPTION_KEY, description);
+                final ParameterDescriptor<?> descriptor = new DefaultParameterDescriptor<>(properties,
                         1, 1, type, valueDomain, null, null);
                 returnValue = ensureSingleton(descriptor, returnValue, code);
             }

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/CoordinateOperationFinder.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -293,7 +293,9 @@ abstract class CoordinateOperationFinder
         Class<? extends CoordinateOperation> type = null;
         if (op instanceof Transformation)  type = Transformation.class;
         else if (op instanceof Conversion) type = Conversion.class;
-        return createFromMathTransform(properties(INVERSE_OPERATION), targetCRS, sourceCRS,
+        final Map<String,Object> properties = properties(INVERSE_OPERATION);
+        InverseOperationMethod.putParameters(op, properties);
+        return createFromMathTransform(properties, targetCRS, sourceCRS,
                 transform, InverseOperationMethod.create(op.getMethod()), null, type);
     }
 

Modified: sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/InverseOperationMethod.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/InverseOperationMethod.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/InverseOperationMethod.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/InverseOperationMethod.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -19,7 +19,17 @@ package org.apache.sis.referencing.opera
 import java.util.Map;
 import java.util.HashMap;
 import javax.xml.bind.annotation.XmlTransient;
+import javax.measure.unit.Unit;
+import org.opengis.util.InternationalString;
+import org.opengis.parameter.ParameterValue;
+import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.parameter.ParameterDescriptor;
+import org.opengis.parameter.GeneralParameterValue;
+import org.opengis.parameter.GeneralParameterDescriptor;
 import org.opengis.referencing.operation.OperationMethod;
+import org.opengis.referencing.operation.SingleOperation;
+import org.apache.sis.internal.metadata.ReferencingServices;
+import org.apache.sis.internal.referencing.SignReversalComment;
 import org.apache.sis.internal.referencing.provider.AbstractProvider;
 import org.apache.sis.metadata.iso.ImmutableIdentifier;
 import org.apache.sis.util.Deprecable;
@@ -58,24 +68,92 @@ final class InverseOperationMethod exten
     }
 
     /**
-     * Returns or create the inverse of the given operation method.
+     * Returns {@code true} if the given method flags itself as invertible.
+     */
+    private static boolean isInvertible(final OperationMethod method) {
+        return method instanceof AbstractProvider && ((AbstractProvider) method).isInvertible();
+    }
+
+    /**
+     * Returns or create the inverse of the given operation method. If the same operation method can be used
+     * for the inverse operation either with the exact same parameter values or with the sign of some values
+     * reversed, then the given method is returned as-is. Otherwise a synthetic method is created.
      */
     static OperationMethod create(final OperationMethod method) {
         if (method instanceof InverseOperationMethod) {
             return ((InverseOperationMethod) method).inverse;
         }
-        if (method instanceof AbstractProvider && ((AbstractProvider) method).isInvertible()) {
-            return method;
+        if (!isInvertible(method)) {
+            boolean useSameParameters = false;
+            for (final GeneralParameterDescriptor descriptor : method.getParameters().descriptors()) {
+                useSameParameters = (descriptor.getRemarks() instanceof SignReversalComment);
+                if (!useSameParameters) break;
+            }
+            if (!useSameParameters) {
+                Identifier name = method.getName();
+                name = new ImmutableIdentifier(null, name.getCodeSpace(), "Inverse " + name.getCode());
+                final Map<String,Object> properties = new HashMap<>(6);
+                properties.put(NAME_KEY,    name);
+                properties.put(FORMULA_KEY, method.getFormula());
+                properties.put(REMARKS_KEY, method.getRemarks());
+                if (method instanceof Deprecable) {
+                    properties.put(DEPRECATED_KEY, ((Deprecable) method).isDeprecated());
+                }
+                return new InverseOperationMethod(properties, method);
+            }
         }
-        Identifier name = method.getName();
-        name = new ImmutableIdentifier(null, name.getCodeSpace(), "Inverse " + name.getCode());
-        final Map<String,Object> properties = new HashMap<>(6);
-        properties.put(NAME_KEY,    name);
-        properties.put(FORMULA_KEY, method.getFormula());
-        properties.put(REMARKS_KEY, method.getRemarks());
-        if (method instanceof Deprecable) {
-            properties.put(DEPRECATED_KEY, ((Deprecable) method).isDeprecated());
+        return method;
+    }
+
+    /**
+     * If the inverse of the given operation can be represented by inverting the sign of all numerical
+     * parameter values, copies those parameters in a {@code "parameters"} entry in the given map.
+     * Otherwise does nothing.
+     *
+     * @param source  the operation for which to get the inverse parameters.
+     * @param target  where to store the inverse parameters.
+     */
+    static void putParameters(final SingleOperation source, final Map<String,Object> target) {
+        final boolean isInvertible = isInvertible(source.getMethod());
+        final ParameterValueGroup parameters = source.getParameterValues();
+        final ParameterValueGroup copy = parameters.getDescriptor().createValue();
+        for (final GeneralParameterValue gp : parameters.values()) {
+            if (gp instanceof ParameterValue<?>) {
+                final ParameterValue<?> src = (ParameterValue<?>) gp;
+                final Object value = src.getValue();
+                if (value instanceof Number) {
+                    final ParameterDescriptor<?> descriptor = src.getDescriptor();
+                    final InternationalString remarks = descriptor.getRemarks();
+                    if (remarks != SignReversalComment.SAME) {
+                        boolean isOpposite = (remarks == SignReversalComment.OPPOSITE);
+                        if (!isOpposite) {
+                            /*
+                             * If the parameter descriptor does not contain an information about whether the
+                             * inverse operation uses values of opposite sign or not, use heuristic rules.
+                             */
+                            if (!isInvertible) {
+                                return;                 // Can not create inverse parameter values - abandon.
+                            }
+                            final Comparable<?> minimum = descriptor.getMinimumValue();
+                            isOpposite = (minimum == null || (minimum instanceof Number && ((Number) minimum).doubleValue() < 0));
+                        }
+                        if (isOpposite) {
+                            final ParameterValue<?> tgt = copy.parameter(descriptor.getName().getCode());
+                            final Unit<?> unit = src.getUnit();
+                            if (unit != null) {
+                                tgt.setValue(-src.doubleValue(), unit);
+                            } else if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
+                                tgt.setValue(-src.intValue());
+                            } else {
+                                tgt.setValue(-src.doubleValue());
+                            }
+                            continue;
+                        }
+                    }
+                }
+            }
+            copy.values().add(gp);
         }
-        return new InverseOperationMethod(properties, method);
+        target.put(ReferencingServices.PARAMETERS_KEY, copy);
     }
 }

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/ReferencingUtilitiesTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/ReferencingUtilitiesTest.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/ReferencingUtilitiesTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/internal/referencing/ReferencingUtilitiesTest.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -90,8 +90,9 @@ public final strictfp class ReferencingU
      */
     @Test
     public void testGetPropertiesForModifiedCRS() {
-        assertEquals("WGS 84", getPropertiesForModifiedCRS(HardCodedCRS.WGS84_3D).get(IdentifiedObject.NAME_KEY));
-        assertEquals("WGS 84", getPropertiesForModifiedCRS(HardCodedCRS.GEOID_4D).get(IdentifiedObject.NAME_KEY));
+        assertEquals("WGS 84",      getPropertiesForModifiedCRS(HardCodedCRS.WGS84_3D).get(IdentifiedObject.NAME_KEY));
+        assertEquals("WGS 84",      getPropertiesForModifiedCRS(HardCodedCRS.GEOID_4D).get(IdentifiedObject.NAME_KEY));
+        assertEquals("NTF (Paris)", getPropertiesForModifiedCRS(HardCodedCRS.NTF)     .get(IdentifiedObject.NAME_KEY));
     }
 
     /**

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/factory/sql/EPSGDataFormatter.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/factory/sql/EPSGDataFormatter.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/factory/sql/EPSGDataFormatter.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/factory/sql/EPSGDataFormatter.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -85,8 +85,9 @@ import java.nio.charset.StandardCharsets
  *           and add a {@code CONSTRAINT pk_change PRIMARY KEY (change_id)} line instead.</li>
  *       <li>In the statement creating the {@code epsg_datum} table,
  *           change the type of the {@code realization_epoch} column to {@code SMALLINT}.</li>
- *       <li>Change the type of {@code show_crs}, {@code show_operation} and all {@code deprecated} fields
- *           from {@code SMALLINT} to {@code BOOLEAN}.</li>
+ *       <li>Change the type of {@code ellipsoid_shape}, {@code reverse_op}, {@code param_sign_reversal}
+ *           {@code show_crs}, {@code show_operation} and all {@code deprecated} fields from {@code SMALLINT}
+ *           (or sometime {@code VARCHAR(3)}) to {@code BOOLEAN}.</li>
  *       <li>Change the type of every {@code table_name} columns from {@code VARCHAR(80)} to {@code epsg_table_name}.</li>
  *       <li>Change the type of {@code coord_ref_sys_kind} column from {@code VARCHAR(24)} to {@code epsg_crs_kind}.</li>
  *       <li>Change the type of {@code coord_sys_type} column from {@code VARCHAR(24)} to {@code epsg_cs_kind}.</li>
@@ -175,15 +176,16 @@ public final class EPSGDataFormatter ext
     private boolean insertDatum;
 
     /**
-     * Number of columns to change from type SMALLINT to type BOOLEAN.
-     * All those columns must be last.
+     * Index (in reversal order) of columns to change from type SMALLINT to type BOOLEAN.
+     * Index 0 is the last columns, index 1 is the column before the last, <i>etc</i>.
+     * We use the reverse order because most boolean columns in the EPSG dataset are last.
      */
-    private int numBooleanColumns;
+    private int[] booleanColumnIndices;
 
     /**
-     * The {@link #numBooleanColumns} value for each table.
+     * The {@link #booleanColumnIndices} value for each table.
      */
-    private final Map<String,Integer> numBooleanColumnsForTables;
+    private final Map<String,int[]> booleanColumnIndicesForTables;
 
     /**
      * Creates a new instance.
@@ -193,28 +195,29 @@ public final class EPSGDataFormatter ext
      */
     private EPSGDataFormatter(final Connection c) throws SQLException {
         super(c, Integer.MAX_VALUE);
-        numBooleanColumnsForTables = new HashMap<>();
-        numBooleanColumnsForTables.put("epsg_alias",                     0);
-        numBooleanColumnsForTables.put("epsg_area",                      1);
-        numBooleanColumnsForTables.put("epsg_change",                    0);
-        numBooleanColumnsForTables.put("epsg_coordinateaxis",            0);
-        numBooleanColumnsForTables.put("epsg_coordinateaxisname",        1);
-        numBooleanColumnsForTables.put("epsg_coordinatereferencesystem", 2);
-        numBooleanColumnsForTables.put("epsg_coordinatesystem",          1);
-        numBooleanColumnsForTables.put("epsg_coordoperation",            2);
-        numBooleanColumnsForTables.put("epsg_coordoperationmethod",      1);
-        numBooleanColumnsForTables.put("epsg_coordoperationparam",       1);
-        numBooleanColumnsForTables.put("epsg_coordoperationparamusage",  0);
-        numBooleanColumnsForTables.put("epsg_coordoperationparamvalue",  0);
-        numBooleanColumnsForTables.put("epsg_coordoperationpath",        0);
-        numBooleanColumnsForTables.put("epsg_datum",                     1);
-        numBooleanColumnsForTables.put("epsg_deprecation",               0);
-        numBooleanColumnsForTables.put("epsg_ellipsoid",                 1);
-        numBooleanColumnsForTables.put("epsg_namingsystem",              1);
-        numBooleanColumnsForTables.put("epsg_primemeridian",             1);
-        numBooleanColumnsForTables.put("epsg_supersession",              0);
-        numBooleanColumnsForTables.put("epsg_unitofmeasure",             1);
-        numBooleanColumnsForTables.put("epsg_versionhistory",            0);
+        final Map<String,int[]> m = new HashMap<>();
+        m.put("epsg_alias",                     new int[] {   });
+        m.put("epsg_area",                      new int[] {0  });
+        m.put("epsg_change",                    new int[] {   });
+        m.put("epsg_coordinateaxis",            new int[] {   });
+        m.put("epsg_coordinateaxisname",        new int[] {0  });
+        m.put("epsg_coordinatereferencesystem", new int[] {0,1});
+        m.put("epsg_coordinatesystem",          new int[] {0  });
+        m.put("epsg_coordoperation",            new int[] {0,1});
+        m.put("epsg_coordoperationmethod",      new int[] {0,8});
+        m.put("epsg_coordoperationparam",       new int[] {0  });
+        m.put("epsg_coordoperationparamusage",  new int[] {0  });
+        m.put("epsg_coordoperationparamvalue",  new int[] {   });
+        m.put("epsg_coordoperationpath",        new int[] {   });
+        m.put("epsg_datum",                     new int[] {0  });
+        m.put("epsg_deprecation",               new int[] {   });
+        m.put("epsg_ellipsoid",                 new int[] {0,6});
+        m.put("epsg_namingsystem",              new int[] {0  });
+        m.put("epsg_primemeridian",             new int[] {0  });
+        m.put("epsg_supersession",              new int[] {   });
+        m.put("epsg_unitofmeasure",             new int[] {0  });
+        m.put("epsg_versionhistory",            new int[] {   });
+        booleanColumnIndicesForTables = m;
     }
 
     /**
@@ -302,14 +305,17 @@ public final class EPSGDataFormatter ext
                 return 0;
             }
             /*
-             * Following statements do not make sense anymore on enumerated values:
+             * Following statements do not make sense anymore on enumerated or boolean values:
              *
              *    UPDATE epsg_coordinatereferencesystem SET coord_ref_sys_kind = replace(coord_ref_sys_kind, CHR(182), CHR(10));
              *    UPDATE epsg_coordinatesystem SET coord_sys_type = replace(coord_sys_type, CHR(182), CHR(10));
              *    UPDATE epsg_datum SET datum_type = replace(datum_type, CHR(182), CHR(10));
+             *    UPDATE epsg_coordoperationparamusage SET param_sign_reversal = replace(param_sign_reversal, CHR(182), CHR(10))
              */
             if (line.contains("replace")) {
-                if (line.contains("coord_ref_sys_kind") || line.contains("coord_sys_type") || line.contains("datum_type")) {
+                if (line.contains("param_sign_reversal") || line.contains("coord_ref_sys_kind")
+                        || line.contains("coord_sys_type") || line.contains("datum_type"))
+                {
                     return 0;
                 }
             }
@@ -337,7 +343,7 @@ public final class EPSGDataFormatter ext
                 throw new SQLException("This simple program wants VALUES on the same line than INSERT INTO.");
             }
             final String table = CharSequences.trimWhitespaces(line, INSERT_INTO.length(), valuesStart).toString();
-            numBooleanColumns = numBooleanColumnsForTables.get(table);
+            booleanColumnIndices = booleanColumnIndicesForTables.get(table);
             insertDatum = table.equals("epsg_datum");
             /*
              * We are beginning insertions in a new table.
@@ -383,20 +389,40 @@ public final class EPSGDataFormatter ext
      */
     private String replaceIntegerByBoolean(final String line) throws SQLException {
         final StringBuilder buffer = new StringBuilder(line);
-        int end = line.length();
-        for (int n = 0; n < numBooleanColumns; n++) {
-            end = line.lastIndexOf(',', end - 1);
-            final int p = CharSequences.skipLeadingWhitespaces(line, end+1, line.length());
-            final boolean value;
-            switch (line.charAt(p)) {
-                case '0': value = false; break;
-                case '1': value = true;  break;
-                default: throw new SQLException("Unexpected boolean value at position " + p + " in:\n" + line);
+        int end = CharSequences.skipTrailingWhitespaces(buffer, 0, buffer.length());
+        if (buffer.codePointBefore(end) == ')') end--;
+        for (int n=0, columnIndex=0; n < booleanColumnIndices.length; columnIndex++) {
+            int start = end;
+            for (int c; (c = buffer.codePointBefore(start)) != ',';) {
+                start -= Character.charCount(c);
+                if (c == '\'') {
+                    while (true) {
+                        c = buffer.codePointBefore(start);
+                        start -= Character.charCount(c);
+                        if (c == '\'') {
+                            if (buffer.codePointBefore(start) != '\'') {
+                                break;
+                            }
+                            start--;
+                        }
+                    }
+                }
             }
-            if (line.charAt(p+1) != (n == 0 ? ' ' : ',')) {
-                throw new SQLException("Unexpected character at position " + (p+1) + " in:\n" + line);
+            if (columnIndex == booleanColumnIndices[n]) {
+                String value = CharSequences.trimWhitespaces(buffer, start, end).toString();
+                if (value.equals("0") || value.equalsIgnoreCase("'No'")) {
+                    value = "false";
+                } else if (value.equals("1") || value.equalsIgnoreCase("'Yes'")) {
+                    value = "true";
+                } else if (value.equalsIgnoreCase("Null") || value.equals("''")) {
+                    value = "Null";
+                } else {
+                    throw new SQLException("Unexpected boolean value \"" + value + "\" at position " + start + " in:\n" + line);
+                }
+                buffer.replace(start, end, value);
+                n++;
             }
-            buffer.replace(p, p+1, String.valueOf(value));
+            end = CharSequences.skipTrailingWhitespaces(buffer, 0, start - 1);
         }
         return buffer.toString();
     }
@@ -410,6 +436,7 @@ public final class EPSGDataFormatter ext
     /**
      * Removes the useless "E0" exponents after floating point numbers.
      */
+    @SuppressWarnings("null")
     private static String removeUselessExponents(String line) {
         StringBuilder cleaned = null;
         final Matcher matcher = uselessExponentPattern.matcher(line);

Modified: sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationRegistryTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationRegistryTest.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationRegistryTest.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-referencing/src/test/java/org/apache/sis/referencing/operation/CoordinateOperationRegistryTest.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -18,8 +18,10 @@ package org.apache.sis.referencing.opera
 
 import java.util.List;
 import java.text.ParseException;
+import org.opengis.metadata.Identifier;
 import org.opengis.util.FactoryException;
 import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.referencing.IdentifiedObject;
 import org.opengis.referencing.crs.CRSAuthorityFactory;
 import org.opengis.referencing.crs.CoordinateReferenceSystem;
 import org.opengis.referencing.operation.SingleOperation;
@@ -28,6 +30,8 @@ import org.opengis.referencing.operation
 import org.opengis.referencing.operation.CoordinateOperationAuthorityFactory;
 import org.opengis.referencing.operation.TransformException;
 import org.apache.sis.internal.referencing.Formulas;
+import org.apache.sis.referencing.crs.DefaultGeographicCRS;
+import org.apache.sis.referencing.cs.AxesConvention;
 import org.apache.sis.referencing.CommonCRS;
 import org.apache.sis.referencing.CRS;
 import org.apache.sis.io.wkt.WKTFormat;
@@ -155,10 +159,7 @@ public final strictfp class CoordinateOp
 
         final CoordinateReferenceSystem targetCRS = CommonCRS.WGS84.geographic();
         final CoordinateOperation operation = registry.createOperation(sourceCRS, targetCRS);
-        assertEpsgNameAndIdentifierEqual("NTF (Paris) to WGS 84 (1)", 8094, operation);
-        assertEpsgNameAndIdentifierEqual("NTF (Paris)", 4807, operation.getSourceCRS());
-        assertEpsgNameAndIdentifierEqual("WGS 84",      4326, operation.getTargetCRS());
-        verifyNTF(operation, "geog2D domain");
+        verifyNTF(operation, "geog2D domain", true);
         /*
          * Same test point than the one used in FranceGeocentricInterpolationTest:
          *
@@ -196,7 +197,7 @@ public final strictfp class CoordinateOp
 
         final CoordinateReferenceSystem targetCRS = CommonCRS.WGS84.normalizedGeographic();
         final CoordinateOperation operation = registry.createOperation(sourceCRS, targetCRS);
-        verifyNTF(operation, "geog2D domain");
+        verifyNTF(operation, "geog2D domain", false);
 
         transform  = operation.getMathTransform();
         tolerance  = Formulas.ANGULAR_TOLERANCE;
@@ -207,6 +208,36 @@ public final strictfp class CoordinateOp
     }
 
     /**
+     * Tests the inverse of <cite>"NTF (Paris) to WGS 84 (1)"</cite> operation, also with different axis order.
+     *
+     * @throws ParseException if a CRS used in this test can not be parsed.
+     * @throws FactoryException if the operation can not be created.
+     * @throws TransformException if an error occurred while converting the test points.
+     */
+    @Test
+    @DependsOnMethod("testLongitudeRotationBetweenNormalizedCRS")
+    public void testInverse() throws ParseException, FactoryException, TransformException {
+        final CoordinateReferenceSystem targetCRS = parse(
+                "GeodeticCRS[“NTF (Paris)”,\n" +
+                "  $NTF,\n" +
+                "    PrimeMeridian[“Paris”, 2.5969213],\n" +
+                "  CS[ellipsoidal, 2],\n" +
+                "    Axis[“Longitude (λ)”, EAST],\n" +
+                "    Axis[“Latitude (φ)”, NORTH],\n" +
+                "    Unit[“grade”, 0.015707963267948967]]");
+
+        final CoordinateReferenceSystem sourceCRS = CommonCRS.WGS84.normalizedGeographic();
+        final CoordinateOperation operation = registry.createOperation(sourceCRS, targetCRS);
+
+        transform  = operation.getMathTransform();
+        tolerance  = Formulas.ANGULAR_TOLERANCE;
+        λDimension = new int[] {1};
+        verifyTransform(new double[] {2.424952028, 48.844443528},      // in degrees east of Greenwich
+                        new double[] {0.098269657, 54.271680278});     // in grads east of Paris
+        validate();
+    }
+
+    /**
      * Tests <cite>"NTF (Paris) to WGS 84 (1)"</cite> operation with three-dimensional source and target CRS.
      * {@link CoordinateOperationRegistry} should be able to find the operation despite the difference in
      * number of dimensions.
@@ -229,7 +260,7 @@ public final strictfp class CoordinateOp
 
         final CoordinateReferenceSystem targetCRS = CommonCRS.WGS84.geographic3D();
         final CoordinateOperation operation = registry.createOperation(sourceCRS, targetCRS);
-        verifyNTF(operation, "geog3D domain");
+        verifyNTF(operation, "geog3D domain", false);
 
         transform  = operation.getMathTransform();
         tolerance  = Formulas.ANGULAR_TOLERANCE;
@@ -242,26 +273,66 @@ public final strictfp class CoordinateOp
     }
 
     /**
+     * Tests <cite>"NTF (Paris) to WGS 84 (1)"</cite> operation with three-dimensional source and target CRS
+     * having different axis order and units than the ones declared in the EPSG dataset.
+     *
+     * @throws ParseException if a CRS used in this test can not be parsed.
+     * @throws FactoryException if the operation can not be created.
+     * @throws TransformException if an error occurred while converting the test points.
+     */
+    @Test
+    @DependsOnMethod({"testLongitudeRotationBetweenNormalizedCRS", "testLongitudeRotationBetweenGeographic3D"})
+    public void testLongitudeRotationBetweenNormalizedGeographic3D() throws ParseException, FactoryException, TransformException {
+        final CoordinateReferenceSystem sourceCRS = parse(
+                "GeodeticCRS[“NTF (Paris)”,\n" +
+                "  $NTF,\n" +
+                "    PrimeMeridian[“Paris”, 2.33722917],\n" +
+                "  CS[ellipsoidal, 3],\n" +
+                "    Axis[“Longitude (λ)”, EAST, Unit[“degree”, 0.017453292519943295]],\n" +
+                "    Axis[“Latitude (φ)”, NORTH, Unit[“degree”, 0.017453292519943295]],\n" +
+                "    Axis[“Height (h)”, UP, Unit[“m”, 1]]]");
+
+        final CoordinateReferenceSystem targetCRS =
+                DefaultGeographicCRS.castOrCopy(CommonCRS.WGS84.geographic3D()).forConvention(AxesConvention.NORMALIZED);
+        final CoordinateOperation operation = registry.createOperation(sourceCRS, targetCRS);
+        verifyNTF(operation, "geog3D domain", false);
+
+        transform  = operation.getMathTransform();
+        tolerance  = Formulas.ANGULAR_TOLERANCE;
+        zTolerance = Formulas.LINEAR_TOLERANCE;
+        zDimension = new int[] {2};
+        λDimension = new int[] {1};
+        verifyTransform(new double[] {0.088442691, 48.844512250, 20.00},      // in degrees east of Paris
+                        new double[] {2.424952028, 48.844443528, 63.15});     // in degrees east of Greenwich
+        validate();
+    }
+
+    /**
      * Verifies a coordinate operation which is expected to be <cite>"NTF (Paris) to WGS 84 (1)"</cite> (EPSG:8094).
      *
      * @param domain  either {@code "geog2D domain"} or either {@code "geog3D domain"}.
+     * @param isEPSG  {@code true} if the coordinate operation is expected to contain EPSG identifiers.
      */
-    static void verifyNTF(final CoordinateOperation operation, final String domain) {
-        assertEquals("name",           "NTF (Paris) to WGS 84 (1)",  operation.getName().getCode());
-        assertEquals("sourceCRS.name", "NTF (Paris)",                operation.getSourceCRS().getName().getCode());
-        assertEquals("targetCRS.name", "WGS 84",                     operation.getTargetCRS().getName().getCode());
-        assertEquals("Should report only the coarsest accuracy.", 1, operation.getCoordinateOperationAccuracy().size());
-        assertEquals("linearAccuracy",                            2, CRS.getLinearAccuracy(operation), STRICT);
-
+    static void verifyNTF(final CoordinateOperation operation, final String domain, final boolean isEPSG) {
         assertInstanceOf("Operation should have two steps.", ConcatenatedOperation.class, operation);
         final List<? extends CoordinateOperation> steps = ((ConcatenatedOperation) operation).getOperations();
         assertEquals("Operation should have two steps.", 2, steps.size());
-
         final SingleOperation step1 = (SingleOperation) steps.get(0);
         final SingleOperation step2 = (SingleOperation) steps.get(1);
+        if (isEPSG) {
+            assertEpsgNameAndIdentifierEqual("NTF (Paris) to WGS 84 (1)", 8094, operation);
+            assertEpsgNameAndIdentifierEqual("NTF (Paris)",               4807, operation.getSourceCRS());
+            assertEpsgNameAndIdentifierEqual("WGS 84",                    4326, operation.getTargetCRS());
+            assertEpsgNameAndIdentifierEqual("NTF (Paris) to NTF (1)",    1763, step1);
+            assertEpsgNameAndIdentifierEqual("NTF to WGS 84 (1)",         1193, step2);
+        } else {
+            assertEpsgNameWithoutIdentifierEqual("NTF (Paris) to WGS 84 (1)", operation);
+            assertEpsgNameWithoutIdentifierEqual("NTF (Paris)",               operation.getSourceCRS());
+            assertEpsgNameWithoutIdentifierEqual("WGS 84",                    operation.getTargetCRS());
+            assertEpsgNameWithoutIdentifierEqual("NTF (Paris) to NTF (1)",    step1);
+            assertEpsgNameWithoutIdentifierEqual("NTF to WGS 84 (1)",         step2);
+        }
         assertSame("SourceCRS shall be the targetCRS of previous step.",     step1.getTargetCRS(), step2.getSourceCRS());
-        assertEquals("Step 1",   "NTF (Paris) to NTF (1)",                   step1.getName().getCode());
-        assertEquals("Step 2",   "NTF to WGS 84 (1)",                        step2.getName().getCode());
         assertEquals("Method 1", "Longitude rotation",                       step1.getMethod().getName().getCode());
         assertEquals("Method 2", "Geocentric translations (" + domain + ')', step2.getMethod().getName().getCode());
 
@@ -271,5 +342,25 @@ public final strictfp class CoordinateOp
         assertEquals("X-axis translation",    -168, p2.parameter("X-axis translation").doubleValue(), STRICT);
         assertEquals("Y-axis translation",     -60, p2.parameter("Y-axis translation").doubleValue(), STRICT);
         assertEquals("Z-axis translation",     320, p2.parameter("Z-axis translation").doubleValue(), STRICT);
+
+        assertEquals("Should report only the coarsest accuracy.", 1, operation.getCoordinateOperationAccuracy().size());
+        assertEquals("linearAccuracy",                            2, CRS.getLinearAccuracy(operation), STRICT);
+    }
+
+    /**
+     * Asserts that the given object has the expected name but no identifier. This method is used when the given object
+     * has been modified compared to the object declared in the EPSG dataset, for example with a change of axis order
+     * or the addition of height. In such case the modified object is not allowed to have the EPSG identifier of the
+     * original object.
+     *
+     * @param name    The expected EPSG name.
+     * @param object  The object to verify.
+     */
+    private static void assertEpsgNameWithoutIdentifierEqual(final String name, final IdentifiedObject object) {
+        assertNotNull(name, object);
+        assertEquals("name", name, object.getName().getCode());
+        for (final Identifier id : object.getIdentifiers()) {
+            assertFalse("EPSG identifier not allowed for modified objects.", "EPSG".equalsIgnoreCase(id.getCodeSpace()));
+        }
     }
 }

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.java?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.java [UTF-8] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.java [UTF-8] Tue Apr 12 17:13:26 2016
@@ -208,6 +208,16 @@ public final class Messages extends Inde
         public static final short InsertDuration_2 = 40;
 
         /**
+         * Inverse operation uses this parameter value with opposite sign.
+         */
+        public static final short InverseOperationUsesOppositeSign = 42;
+
+        /**
+         * Inverse operation uses the same parameter value.
+         */
+        public static final short InverseOperationUsesSameSign = 43;
+
+        /**
          * No object associated to the “{0}” JNDI name.
          */
         public static final short JNDINotSpecified_1 = 32;

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.properties
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.properties?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.properties [ISO-8859-1] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages.properties [ISO-8859-1] Tue Apr 12 17:13:26 2016
@@ -44,6 +44,8 @@ IgnoredPropertyAssociatedTo_1    = Ignor
 IgnoredServiceProvider_3         = More than one service provider of type \u2018{0}\u2019 are declared for \u201c{1}\u201d. Only the first provider (an instance of \u2018{2}\u2019) will be used.
 IncompleteParsing_1              = Parsing of \u201c{0}\u201d done, but some elements were ignored.
 InsertDuration_2                 = Inserted {0} records in {1} seconds.
+InverseOperationUsesSameSign     = Inverse operation uses the same parameter value.
+InverseOperationUsesOppositeSign = Inverse operation uses this parameter value with opposite sign.
 JNDINotSpecified_1               = No object associated to the \u201c{0}\u201d JNDI name.
 LoadingDatumShiftFile_1          = Loading datum shift file \u201c{0}\u201d.
 LocalesDiscarded                 = Text were discarded for some locales.

Modified: sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages_fr.properties
URL: http://svn.apache.org/viewvc/sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages_fr.properties?rev=1738832&r1=1738831&r2=1738832&view=diff
==============================================================================
--- sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages_fr.properties [ISO-8859-1] (original)
+++ sis/branches/JDK8/core/sis-utility/src/main/java/org/apache/sis/util/resources/Messages_fr.properties [ISO-8859-1] Tue Apr 12 17:13:26 2016
@@ -51,6 +51,8 @@ IgnoredPropertyAssociatedTo_1    = Une p
 IgnoredServiceProvider_3         = Plusieurs fournisseurs de service de type \u2018{0}\u2019 sont d\u00e9clar\u00e9s pour \u00ab\u202f{1}\u202f\u00bb. Seul le premier fournisseur (une instance de \u2018{2}\u2019) sera utilis\u00e9.
 IncompleteParsing_1              = La lecture de \u00ab\u202f{0}\u202f\u00bb a \u00e9t\u00e9 faite, mais en ignorant certains \u00e9l\u00e9ments.
 InsertDuration_2                 = {0} enregistrements ont \u00e9t\u00e9 ajout\u00e9s en {1} secondes.
+InverseOperationUsesSameSign     = L\u2019op\u00e9ration inverse utilise la m\u00eame valeur pour ce param\u00e8tre.
+InverseOperationUsesOppositeSign = L\u2019op\u00e9ration inverse utilise ce param\u00e8tre avec la valeur de signe oppos\u00e9.
 JNDINotSpecified_1               = Aucun objet n\u2019est associ\u00e9 au nom JNDI \u00ab\u202f{0}\u202f\u00bb.
 LoadingDatumShiftFile_1          = Chargement du fichier de changement de r\u00e9f\u00e9rentiel \u00ab\u202f{0}\u202f\u00bb.
 LocalesDiscarded                 = Des textes ont \u00e9t\u00e9 ignor\u00e9s pour certaines langues.



Mime
View raw message