Package org.openjdk.jmc.common.unit

Class ComparableConstraint<T extends Comparable<T>>

java.lang.Object

org.openjdk.jmc.common.unit.ComparableConstraint<T>

Type Parameters:

T - the type of values that the constraint operates on

All Implemented Interfaces:

IConstraint<T>, IFormatter<T>

public final class ComparableConstraint<T extends Comparable<T>>
extends Object
implements IConstraint<T>, IFormatter<T>

A constraint that wraps a persister for Comparable values, and constrains the allowed values with minimum and maximum values.

Constructor Summary

Constructors

Constructor	Description
ComparableConstraint(IPersister<T> persister, T min, T max)

Method Summary

Modifier and Type	Method	Description
ComparableConstraint<T>	combine(IConstraint<?> other)	Return a constraint that honors both this constraint and other, if such a constraint would accept anything except null.
protected ComparableConstraint<T>	combineNonSame(ComparableConstraint<T> other)	Combine with other ComparableConstraint known not to be the same instance, but having the same persister.
static <U,T extends Comparable<T>> IConstraint<U>	constrain(IConstraint<U> constraint, String persistedMin, String persistedMax)
static <U,T extends Comparable<T>> IConstraint<U>	constrain(IConstraint<U> constraint, U min, U max)
String	format(T value)
String	interactiveFormat(T value)	An exact string representation taking locale and internationalization into account.
T	parseInteractive(String interactiveValue)	Parse an interactive string.
T	parsePersisted(String persistedValue)	Parse a persisted string.
String	persistableString(T value)	A string representation independent of locale or internationalization, that when parsed using IConstraint.parsePersisted(String) (on this instance) yields a result that is equal to the given value.
boolean	validate(T value)	Fundamentally, check that value satisfies this constraint and throw an exception otherwise.
protected boolean	validateRange(T value)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ComparableConstraint

public ComparableConstraint(IPersister<T> persister,
                            T min,
                            T max)

Method Detail

constrain

public static <U,T extends Comparable<T>> IConstraint<U> constrain(IConstraint<U> constraint,
                                                                         String persistedMin,
                                                                         String persistedMax)
                                                                  throws QuantityConversionException

Throws:

QuantityConversionException

constrain

public static <U,T extends Comparable<T>> IConstraint<U> constrain(IConstraint<U> constraint,
                                                                         U min,
                                                                         U max)

combine

public ComparableConstraint<T> combine(IConstraint<?> other)

Description copied from interface: IConstraint

Return a constraint that honors both this constraint and other, if such a constraint would accept anything except null. Otherwise, return null.

Specified by:

combine in interface IConstraint<T extends Comparable<T>>

Returns:

a constraint or null

combineNonSame

protected ComparableConstraint<T> combineNonSame(ComparableConstraint<T> other)

Combine with other ComparableConstraint known not to be the same instance, but having the same persister.

Returns:

a combined constraint, if possible, otherwise null

validate

public boolean validate(T value)
                 throws QuantityConversionException

Description copied from interface: IConstraint

Fundamentally, check that value satisfies this constraint and throw an exception otherwise. As long as the method returns normally, value is a valid value, regardless of the return value. However, when wrapping a persister in a constraint, it is possible that the persister treats some magic values differently. If the constraint isn't aware of these magical values it should typically not try to validate them. This is signaled by the persister by returning true from this method.

Specified by:

validate in interface IConstraint<T extends Comparable<T>>

Returns:

true if this value is considered magical and further validation should be skipped, false otherwise. Any return value mean that the value is valid.

Throws:

QuantityConversionException - if the constraint isn't satisfied in some other way

validateRange

protected boolean validateRange(T value)
                         throws QuantityConversionException

Throws:

QuantityConversionException

persistableString

public String persistableString(T value)
                         throws QuantityConversionException

Description copied from interface: IConstraint

A string representation independent of locale or internationalization, that when parsed using IConstraint.parsePersisted(String) (on this instance) yields a result that is equal to the given value. That is, the exact representation must be preserved.

Specified by:

persistableString in interface IConstraint<T extends Comparable<T>>

Returns:

a string representation independent of locale or internationalization.

Throws:

QuantityConversionException - if the constraint isn't satisfied in some other way

parsePersisted

public T parsePersisted(String persistedValue)
                 throws QuantityConversionException

Description copied from interface: IConstraint

Parse a persisted string. Only guaranteed to be able to parse strings produced by IConstraint.persistableString(Object) on this instance. Only use this on persisted strings, never for interactive input.

Specified by:

parsePersisted in interface IConstraint<T extends Comparable<T>>

Returns:

a valid value for this instance

Throws:

QuantityConversionException - if persistedValue couldn't be parsed or didn't satisfy the constraint

interactiveFormat

public String interactiveFormat(T value)
                         throws QuantityConversionException

Description copied from interface: IConstraint

An exact string representation taking locale and internationalization into account. When parsed using IConstraint.parseInteractive(String) (on this instance) yields a result that is equal to the given value. That is, the exact representation must be preserved.

Specified by:

interactiveFormat in interface IConstraint<T extends Comparable<T>>

Returns:

a string representation taking locale and internationalization into account.

Throws:

QuantityConversionException - if value doesn't satisfy the constraint

parseInteractive

public T parseInteractive(String interactiveValue)
                   throws QuantityConversionException

Description copied from interface: IConstraint

Parse an interactive string. Only guaranteed to be able to parse strings produced by IConstraint.interactiveFormat(Object) on this instance and in the same locale. Only use this for interactive input, never for persisted strings.

Specified by:

parseInteractive in interface IConstraint<T extends Comparable<T>>

Returns:

a valid value for this instance

Throws:

QuantityConversionException - if interactiveValue couldn't be parsed or didn't satisfy the constraint

format

public String format(T value)

Specified by:

format in interface IFormatter<T extends Comparable<T>>