public ParamDescriptor(Param param) { super( DefaultParameterDescriptor.create( param.key, param.description, param.type, param.sample, param.required)); this.param = param; }
/** * Constructs a parameter group with default name format matching <cite><A * HREF="http://geoapi.sourceforge.net/snapshot/javadoc/org/opengis/referencing/doc-files/WKT.html">Well * Known Text</A></cite> usages. * * @param properties Set of properties. Should contains at least {@code "name"}. */ public MatrixParameterDescriptors(final Map<String, ?> properties) { /* * Note: the upper limit given in the operation parameters is arbitrary. A high * value doesn't make much sense anyway since matrix size for projective * transform will usually not be much more than 5, and the storage scheme * used in this implementation is inefficient for large amount of matrix * elements. */ this( properties, new ParameterDescriptor[] { DefaultParameterDescriptor.create("num_row", DEFAULT_MATRIX_SIZE, 2, 50), DefaultParameterDescriptor.create("num_col", DEFAULT_MATRIX_SIZE, 2, 50) }, "elt_", '_'); }
private DomainDescriptor( final String identifier, final DomainType domainType, final String dataType, final String propertyName, final String additionalPropertyName) { this.identifier = identifier; this.propertyName = propertyName; this.domainType = domainType; this.dataType = dataType; this.additionalPropertyName = additionalPropertyName; final String name = identifier.toUpperCase(); this.domainParameterDescriptor = DefaultParameterDescriptor.create( name, "Additional " + identifier + " domain", List.class, null, false); }
/** * Constructs a descriptor for a mandatory parameter in a range of integer values. * * @param name The parameter name. * @param defaultValue The default value for the parameter. * @param minimum The minimum parameter value, or {@link Integer#MIN_VALUE} if none. * @param maximum The maximum parameter value, or {@link Integer#MAX_VALUE} if none. * @return The parameter descriptor for the given range of values. * @since 2.5 */ public static DefaultParameterDescriptor<Integer> create( final String name, final int defaultValue, final int minimum, final int maximum) { return create( Collections.singletonMap(NAME_KEY, name), defaultValue, minimum, maximum, true); }
/** * Constructs a descriptor for a mandatory parameter in a range of floating point values. * * @param name The parameter name. * @param defaultValue The default value for the parameter, or {@link Double#NaN} if none. * @param minimum The minimum parameter value, or {@link Double#NEGATIVE_INFINITY} if none. * @param maximum The maximum parameter value, or {@link Double#POSITIVE_INFINITY} if none. * @param unit The unit for default, minimum and maximum values. * @return The parameter descriptor for the given range of values. * @since 2.5 */ public static DefaultParameterDescriptor<Double> create( final String name, final double defaultValue, final double minimum, final double maximum, final Unit<?> unit) { return create( Collections.singletonMap(NAME_KEY, name), defaultValue, minimum, maximum, unit, true); }
/** * Constructs a parameter from the specified name and value. This convenience constructor * creates a {@link DefaultParameterDescriptor} object. But if such an object is available, then * the preferred way to get a {@code ParameterValue} is to invoke {@link * ParameterDescriptor#createValue}. * * @param name The parameter name. * @param value The parameter value. * @return A new parameter instance for the given name and value. * @since 2.5 */ public static Parameter<Integer> create(final String name, final int value) { final ParameterDescriptor<Integer> descriptor = DefaultParameterDescriptor.create(name, 0, Integer.MIN_VALUE, Integer.MAX_VALUE); final Parameter<Integer> parameter = new Parameter<Integer>(descriptor); parameter.value = value; return parameter; }
/** * Constructs a parameter from the specified code list. This convenience constructor creates a * {@link DefaultParameterDescriptor} object. But if such an object is available, then the * preferred way to get a {@code ParameterValue} is to invoke {@link * ParameterDescriptor#createValue}. * * @param <T> The parameter type. * @param name The parameter name. * @param type The parameter type. * @param value The parameter value. * @return A new parameter instance for the given name and value. * @since 2.5 */ public static <T extends CodeList> Parameter<T> create( final String name, final Class<T> type, final T value) { final ParameterDescriptor<T> descriptor = DefaultParameterDescriptor.create(name, null, type, null, true); final Parameter<T> parameter = new Parameter<T>(descriptor); parameter.value = value; return parameter; }
/** * Constructs an optional parameter descriptor from a set of alias. The parameter is identified * as with {@link #createDescriptor}. * * @param identifiers The parameter identifiers. Most contains at least one entry. * @param minimum The minimum parameter value, or {@link Double#NEGATIVE_INFINITY} if none. * @param maximum The maximum parameter value, or {@link Double#POSITIVE_INFINITY} if none. * @param unit The unit for default, minimum and maximum values. * @return The descriptor for the given identifiers. */ protected static ParameterDescriptor<Double> createOptionalDescriptor( final ReferenceIdentifier[] identifiers, final double minimum, final double maximum, final Unit<?> unit) { return DefaultParameterDescriptor.create( toMap(identifiers), Double.NaN, minimum, maximum, unit, false); }
/** * Constructs a parameter descriptor from a set of alias. The parameter is identified by codes * provided by one or more authorities. Common authorities are {@link Citations#OGC OGC} and * {@link Citations#EPSG EPSG} for example. * * <p>The first entry in the {@code identifiers} array is both the {@linkplain * ParameterDescriptor#getName main name} and the {@linkplain ParameterDescriptor#getIdentifiers * identifiers}. All others are {@linkplain ParameterDescriptor#getAlias aliases}. * * @param identifiers The parameter identifiers. Most contains at least one entry. * @param defaultValue The default value for the parameter, or {@link Double#NaN} if none. * @param minimum The minimum parameter value, or {@link Double#NEGATIVE_INFINITY} if none. * @param maximum The maximum parameter value, or {@link Double#POSITIVE_INFINITY} if none. * @param unit The unit for default, minimum and maximum values. * @return The descriptor for the given identifiers. */ protected static ParameterDescriptor<Double> createDescriptor( final ReferenceIdentifier[] identifiers, final double defaultValue, final double minimum, final double maximum, final Unit<?> unit) { return DefaultParameterDescriptor.create( toMap(identifiers), defaultValue, minimum, maximum, unit, true); }
public Set<ParameterDescriptor<List>> getDynamicParameters() throws IOException { if (dynamicParameters == null) { dynamicParameters = new HashSet<ParameterDescriptor<List>>(); List<AdditionalDomain> domains = getAdditionalDomains(); if (domains != null && !domains.isEmpty()) { for (AdditionalDomain domain : domains) { dynamicParameters.add( DefaultParameterDescriptor.create( domain.getName().toUpperCase(), "Additional " + domain.getName() + " domain", List.class, null, false)); } } } return dynamicParameters; } }
/** * Constructs a parameter from the specified name and value. This convenience constructor * creates a {@link DefaultParameterDescriptor} object. But if such an object is available, then * the preferred way to get a {@code ParameterValue} is to invoke {@link * ParameterDescriptor#createValue}. * * @param name The parameter name. * @param value The parameter value. * @param unit The unit for the parameter value. * @return A new parameter instance for the given name and value. * @since 2.5 */ public static Parameter<Double> create(final String name, final double value, Unit<?> unit) { // Normalizes the specified unit into one of "standard" units used in projections. if (unit != null) { if (SI.METRE.isCompatible(unit)) unit = SI.METRE; else if (SI.DAY.isCompatible(unit)) unit = SI.DAY; else if (NonSI.DEGREE_ANGLE.isCompatible(unit)) unit = NonSI.DEGREE_ANGLE; } final ParameterDescriptor<Double> descriptor = DefaultParameterDescriptor.create( name, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, unit); final Parameter<Double> parameter = new Parameter<Double>(descriptor); parameter.value = value; parameter.unit = unit; return parameter; }
public ParamDescriptor(Param param) { super( DefaultParameterDescriptor.create(param.key, param.description, param.type, param.sample, param.required )); this.param = param; } public ParameterValue createValue() {
public Set<ParameterDescriptor<List>> getDynamicParameters() throws IOException { if (dynamicParameters == null) { dynamicParameters = new HashSet<ParameterDescriptor<List>>(); List<AdditionalDomain> domains = getAdditionalDomains(); if (domains != null && !domains.isEmpty()) { for (AdditionalDomain domain : domains) { dynamicParameters.add( DefaultParameterDescriptor.create( domain.getName().toUpperCase(), "Additional " + domain.getName() + " domain", List.class, null, false)); } } } return dynamicParameters; } }
ParameterValue<Double> parameter; dDescriptor = DefaultParameterDescriptor.create("Test", 12, 4, 20, SI.METRE); parameter = dDescriptor.createValue(); assertEquals("name", "Test", dDescriptor.getName().getCode()); iDescriptor = DefaultParameterDescriptor.create("Test", 3, 4, 20); fail("setValue(< min)"); } catch (InvalidParameterValueException exception) { iDescriptor = DefaultParameterDescriptor.create("Test", 12, 20, 4); fail("ParameterDescriptor(min > max)"); } catch (IllegalArgumentException exception) {
public void testRangeIntegers() { Parameter<Integer> param; param = new Parameter(DefaultParameterDescriptor.create("Range", 15, -30, +40)); assertEquals("intValue", 15, param.intValue()); assertEquals("doubleValue", 15, param.doubleValue(), 0.0);
public void testRangeDoubles() { Parameter<Double> param; param = new Parameter(DefaultParameterDescriptor.create("Range", 15.0, -30.0, +40.0, null)); assertEquals("intValue", 15, param.intValue()); assertEquals("doubleValue", 15, param.doubleValue(), 0.0);