external-software/github_OpenIdentityPlatform_OpenDJ.git

			@@ -27,583 +27,501 @@

			package org.opends.server.admin;



			import static org.opends.server.util.Validator.*;
			import static com.forgerock.opendj.util.Validator.*;

			import java.util.EnumSet;



			/**
			* Duration property definition.
			* <p>
			* A duration property definition comprises of:
			* <ul>
			* <li>a <i>base unit</i> - specifies the minimum granularity which
			* can be used to specify duration property values. For example, if
			* the base unit is in seconds then values represented in milliseconds
			* will not be permitted. The default base unit is seconds
			* <li>an optional <i>maximum unit</i> - specifies the biggest
			* duration unit which can be used to specify duration property
			* values. Values presented in units greater than this unit will not
			* be permitted. There is no default maximum unit
			* <li><i>lower limit</i> - specifies the smallest duration
			* permitted by the property. The default lower limit is 0 and can
			* never be less than 0
			* <li>an optional <i>upper limit</i> - specifies the biggest
			* duration permitted by the property. By default, there is no upper
			* limit
			* <li>support for <i>unlimited</i> durations - when permitted users
			* can specify "unlimited" durations. These are represented using the
			* decoded value, -1, or the encoded string value "unlimited". By
			* default, unlimited durations are not permitted. In addition, it is
			* not possible to define an upper limit and support unlimited values.
			* <li>a <i>base unit</i> - specifies the minimum granularity which can be used
			* to specify duration property values. For example, if the base unit is in
			* seconds then values represented in milliseconds will not be permitted. The
			* default base unit is seconds
			* <li>an optional <i>maximum unit</i> - specifies the biggest duration unit
			* which can be used to specify duration property values. Values presented in
			* units greater than this unit will not be permitted. There is no default
			* maximum unit
			* <li><i>lower limit</i> - specifies the smallest duration permitted by the
			* property. The default lower limit is 0 and can never be less than 0
			* <li>an optional <i>upper limit</i> - specifies the biggest duration permitted
			* by the property. By default, there is no upper limit
			* <li>support for <i>unlimited</i> durations - when permitted users can specify
			* "unlimited" durations. These are represented using the decoded value, -1, or
			* the encoded string value "unlimited". By default, unlimited durations are not
			* permitted. In addition, it is not possible to define an upper limit and
			* support unlimited values.
			* </ul>
			* Decoded values are represented using <code>long</code> values in
			* the base unit defined for the duration property definition.
			* Decoded values are represented using <code>long</code> values in the base
			* unit defined for the duration property definition.
			*/
			public final class DurationPropertyDefinition extends PropertyDefinition<Long> {

			// String used to represent unlimited durations.
			private static final String UNLIMITED = "unlimited";

			// The base unit for this property definition.
			private final DurationUnit baseUnit;

			// The optional maximum unit for this property definition.
			private final DurationUnit maximumUnit;

			// The lower limit of the property value in milli-seconds.
			private final long lowerLimit;

			// The optional upper limit of the property value in milli-seconds.
			private final Long upperLimit;

			// Indicates whether this property allows the use of the "unlimited"
			// duration value (represented using a -1L or the string
			// "unlimited").
			private final boolean allowUnlimited;



			/**
			* An interface for incrementally constructing duration property
			* definitions.
			*/
			public static class Builder extends
			AbstractBuilder<Long, DurationPropertyDefinition> {
			// String used to represent unlimited durations.
			private static final String UNLIMITED = "unlimited";

			// The base unit for this property definition.
			private DurationUnit baseUnit = DurationUnit.SECONDS;
			private final DurationUnit baseUnit;

			// The optional maximum unit for this property definition.
			private DurationUnit maximumUnit = null;
			private final DurationUnit maximumUnit;

			// The lower limit of the property value in milli-seconds.
			private long lowerLimit = 0L;
			private final long lowerLimit;

			// The optional upper limit of the property value in
			// milli-seconds.
			private Long upperLimit = null;
			// The optional upper limit of the property value in milli-seconds.
			private final Long upperLimit;

			// Indicates whether this property allows the use of the
			// "unlimited" duration value (represented using a -1L or the
			// string "unlimited").
			private boolean allowUnlimited = false;



			// Private constructor
			private Builder(AbstractManagedObjectDefinition<?, ?> d,
			String propertyName) {
			super(d, propertyName);
			}


			// Indicates whether this property allows the use of the "unlimited"
			// duration value (represented using a -1L or the string
			// "unlimited").
			private final boolean allowUnlimited;

			/**
			* Set the base unit for this property definition (values
			* including limits are specified in this unit). By default a
			* duration property definition uses seconds.
			*
			* @param unit
			* The string representation of the base unit (must not
			* be <code>null</code>).
			* @throws IllegalArgumentException
			* If the provided unit name did not correspond to a
			* known duration unit, or if the base unit is bigger
			* than the maximum unit.
			* An interface for incrementally constructing duration property
			* definitions.
			*/
			public final void setBaseUnit(String unit) throws IllegalArgumentException {
			ensureNotNull(unit);
			public static class Builder extends AbstractBuilder<Long, DurationPropertyDefinition> {

			setBaseUnit(DurationUnit.getUnit(unit));
			}
			// The base unit for this property definition.
			private DurationUnit baseUnit = DurationUnit.SECONDS;

			// The optional maximum unit for this property definition.
			private DurationUnit maximumUnit = null;

			// The lower limit of the property value in milli-seconds.
			private long lowerLimit = 0L;

			/**
			* Set the base unit for this property definition (values
			* including limits are specified in this unit). By default a
			* duration property definition uses seconds.
			*
			* @param unit
			* The base unit (must not be <code>null</code>).
			* @throws IllegalArgumentException
			* If the provided base unit is bigger than the maximum
			* unit.
			*/
			public final void setBaseUnit(DurationUnit unit)
			throws IllegalArgumentException {
			ensureNotNull(unit);
			// The optional upper limit of the property value in
			// milli-seconds.
			private Long upperLimit = null;

			// Make sure that the base unit is not bigger than the maximum
			// unit.
			if (maximumUnit != null) {
			if (unit.getDuration() > maximumUnit.getDuration()) {
			throw new IllegalArgumentException(
			"Base unit greater than maximum unit");
			}
			}
			// Indicates whether this property allows the use of the
			// "unlimited" duration value (represented using a -1L or the
			// string "unlimited").
			private boolean allowUnlimited = false;

			this.baseUnit = unit;
			}



			/**
			* Set the maximum unit for this property definition. By default
			* there is no maximum unit.
			*
			* @param unit
			* The string representation of the maximum unit, or
			* <code>null</code> if there should not be a maximum
			* unit.
			* @throws IllegalArgumentException
			* If the provided unit name did not correspond to a
			* known duration unit, or if the maximum unit is
			* smaller than the base unit.
			*/
			public final void setMaximumUnit(String unit)
			throws IllegalArgumentException {
			if (unit == null) {
			setMaximumUnit((DurationUnit) null);
			} else {
			setMaximumUnit(DurationUnit.getUnit(unit));
			}
			}



			/**
			* Set the maximum unit for this property definition. By default
			* there is no maximum unit.
			*
			* @param unit
			* The maximum unit, or <code>null</code> if there
			* should not be a maximum unit.
			* @throws IllegalArgumentException
			* If the provided maximum unit is smaller than the base
			* unit.
			*/
			public final void setMaximumUnit(DurationUnit unit)
			throws IllegalArgumentException {
			if (unit != null) {
			// Make sure that the maximum unit is not smaller than the
			// base unit.
			if (unit.getDuration() < baseUnit.getDuration()) {
			throw new IllegalArgumentException(
			"Maximum unit smaller than base unit");
			}
			}

			this.maximumUnit = unit;
			}



			/**
			* Set the lower limit in milli-seconds.
			*
			* @param lowerLimit
			* The new lower limit (must be >= 0) in milli-seconds.
			* @throws IllegalArgumentException
			* If a negative lower limit was specified, or the lower
			* limit is greater than the upper limit.
			*/
			public final void setLowerLimit(long lowerLimit)
			throws IllegalArgumentException {
			if (lowerLimit < 0) {
			throw new IllegalArgumentException("Negative lower limit");
			}

			if (upperLimit != null && lowerLimit > upperLimit) {
			throw new IllegalArgumentException(
			"Lower limit greater than upper limit");
			}

			this.lowerLimit = lowerLimit;
			}



			/**
			* Set the lower limit using a string representation of the limit.
			* If the string does not specify a unit, the current base unit
			* will be used.
			*
			* @param lowerLimit
			* The string representation of the new lower limit.
			* @throws IllegalArgumentException
			* If the lower limit could not be parsed, or if a
			* negative lower limit was specified, or the lower
			* limit is greater than the upper limit.
			*/
			public final void setLowerLimit(String lowerLimit)
			throws IllegalArgumentException {
			setLowerLimit(DurationUnit.parseValue(lowerLimit, baseUnit));
			}



			/**
			* Set the upper limit in milli-seconds.
			*
			* @param upperLimit
			* The new upper limit in milli-seconds, or
			* <code>null</code> if there is no upper limit.
			* @throws IllegalArgumentException
			* If a negative upper limit was specified, or the lower
			* limit is greater than the upper limit or unlimited
			* durations are permitted.
			*/
			public final void setUpperLimit(Long upperLimit)
			throws IllegalArgumentException {
			if (upperLimit != null) {
			if (upperLimit < 0) {
			throw new IllegalArgumentException("Negative upper limit");
			// Private constructor
			private Builder(AbstractManagedObjectDefinition<?, ?> d, String propertyName) {
			super(d, propertyName);
			}

			if (lowerLimit > upperLimit) {
			throw new IllegalArgumentException(
			"Lower limit greater than upper limit");
			/**
			* Set the base unit for this property definition (values including
			* limits are specified in this unit). By default a duration property
			* definition uses seconds.
			*
			* @param unit
			* The string representation of the base unit (must not be
			* <code>null</code>).
			* @throws IllegalArgumentException
			* If the provided unit name did not correspond to a known
			* duration unit, or if the base unit is bigger than the
			* maximum unit.
			*/
			public final void setBaseUnit(String unit) throws IllegalArgumentException {
			ensureNotNull(unit);

			setBaseUnit(DurationUnit.getUnit(unit));
			}

			if (allowUnlimited) {
			throw new IllegalArgumentException(
			"Upper limit specified when unlimited durations are permitted");
			/**
			* Set the base unit for this property definition (values including
			* limits are specified in this unit). By default a duration property
			* definition uses seconds.
			*
			* @param unit
			* The base unit (must not be <code>null</code>).
			* @throws IllegalArgumentException
			* If the provided base unit is bigger than the maximum
			* unit.
			*/
			public final void setBaseUnit(DurationUnit unit) throws IllegalArgumentException {
			ensureNotNull(unit);

			// Make sure that the base unit is not bigger than the maximum
			// unit.
			if (maximumUnit != null) {
			if (unit.getDuration() > maximumUnit.getDuration()) {
			throw new IllegalArgumentException("Base unit greater than maximum unit");
			}
			}

			this.baseUnit = unit;
			}
			}

			this.upperLimit = upperLimit;
			/**
			* Set the maximum unit for this property definition. By default there
			* is no maximum unit.
			*
			* @param unit
			* The string representation of the maximum unit, or
			* <code>null</code> if there should not be a maximum unit.
			* @throws IllegalArgumentException
			* If the provided unit name did not correspond to a known
			* duration unit, or if the maximum unit is smaller than the
			* base unit.
			*/
			public final void setMaximumUnit(String unit) throws IllegalArgumentException {
			if (unit == null) {
			setMaximumUnit((DurationUnit) null);
			} else {
			setMaximumUnit(DurationUnit.getUnit(unit));
			}
			}

			/**
			* Set the maximum unit for this property definition. By default there
			* is no maximum unit.
			*
			* @param unit
			* The maximum unit, or <code>null</code> if there should not
			* be a maximum unit.
			* @throws IllegalArgumentException
			* If the provided maximum unit is smaller than the base
			* unit.
			*/
			public final void setMaximumUnit(DurationUnit unit) throws IllegalArgumentException {
			if (unit != null) {
			// Make sure that the maximum unit is not smaller than the
			// base unit.
			if (unit.getDuration() < baseUnit.getDuration()) {
			throw new IllegalArgumentException("Maximum unit smaller than base unit");
			}
			}

			this.maximumUnit = unit;
			}

			/**
			* Set the lower limit in milli-seconds.
			*
			* @param lowerLimit
			* The new lower limit (must be >= 0) in milli-seconds.
			* @throws IllegalArgumentException
			* If a negative lower limit was specified, or the lower
			* limit is greater than the upper limit.
			*/
			public final void setLowerLimit(long lowerLimit) throws IllegalArgumentException {
			if (lowerLimit < 0) {
			throw new IllegalArgumentException("Negative lower limit");
			}

			if (upperLimit != null && lowerLimit > upperLimit) {
			throw new IllegalArgumentException("Lower limit greater than upper limit");
			}

			this.lowerLimit = lowerLimit;
			}

			/**
			* Set the lower limit using a string representation of the limit. If
			* the string does not specify a unit, the current base unit will be
			* used.
			*
			* @param lowerLimit
			* The string representation of the new lower limit.
			* @throws IllegalArgumentException
			* If the lower limit could not be parsed, or if a negative
			* lower limit was specified, or the lower limit is greater
			* than the upper limit.
			*/
			public final void setLowerLimit(String lowerLimit) throws IllegalArgumentException {
			setLowerLimit(DurationUnit.parseValue(lowerLimit, baseUnit));
			}

			/**
			* Set the upper limit in milli-seconds.
			*
			* @param upperLimit
			* The new upper limit in milli-seconds, or <code>null</code>
			* if there is no upper limit.
			* @throws IllegalArgumentException
			* If a negative upper limit was specified, or the lower
			* limit is greater than the upper limit or unlimited
			* durations are permitted.
			*/
			public final void setUpperLimit(Long upperLimit) throws IllegalArgumentException {
			if (upperLimit != null) {
			if (upperLimit < 0) {
			throw new IllegalArgumentException("Negative upper limit");
			}

			if (lowerLimit > upperLimit) {
			throw new IllegalArgumentException("Lower limit greater than upper limit");
			}

			if (allowUnlimited) {
			throw new IllegalArgumentException("Upper limit specified when unlimited durations are permitted");
			}
			}

			this.upperLimit = upperLimit;
			}

			/**
			* Set the upper limit using a string representation of the limit. If
			* the string does not specify a unit, the current base unit will be
			* used.
			*
			* @param upperLimit
			* The string representation of the new upper limit, or
			* <code>null</code> if there is no upper limit.
			* @throws IllegalArgumentException
			* If the upper limit could not be parsed, or if the lower
			* limit is greater than the upper limit.
			*/
			public final void setUpperLimit(String upperLimit) throws IllegalArgumentException {
			if (upperLimit == null) {
			setUpperLimit((Long) null);
			} else {
			setUpperLimit(DurationUnit.parseValue(upperLimit, baseUnit));
			}
			}

			/**
			* Specify whether or not this property definition will allow unlimited
			* values (default is false).
			*
			* @param allowUnlimited
			* <code>true</code> if the property will allow unlimited
			* values, or <code>false</code> otherwise.
			* @throws IllegalArgumentException
			* If unlimited values are to be permitted but there is an
			* upper limit specified.
			*/
			public final void setAllowUnlimited(boolean allowUnlimited) throws IllegalArgumentException {
			if (allowUnlimited && upperLimit != null) {
			throw new IllegalArgumentException("Upper limit specified when unlimited durations are permitted");
			}

			this.allowUnlimited = allowUnlimited;
			}

			/**
			* {@inheritDoc}
			*/
			@Override
			protected DurationPropertyDefinition buildInstance(AbstractManagedObjectDefinition<?, ?> d,
			String propertyName, EnumSet<PropertyOption> options, AdministratorAction adminAction,
			DefaultBehaviorProvider<Long> defaultBehavior) {
			return new DurationPropertyDefinition(d, propertyName, options, adminAction, defaultBehavior, baseUnit,
			maximumUnit, lowerLimit, upperLimit, allowUnlimited);
			}
			}



			/**
			* Set the upper limit using a string representation of the limit.
			* If the string does not specify a unit, the current base unit
			* will be used.
			* Create a duration property definition builder.
			*
			* @param upperLimit
			* The string representation of the new upper limit, or
			* <code>null</code> if there is no upper limit.
			* @throws IllegalArgumentException
			* If the upper limit could not be parsed, or if the
			* lower limit is greater than the upper limit.
			* @param d
			* The managed object definition associated with this property
			* definition.
			* @param propertyName
			* The property name.
			* @return Returns the new integer property definition builder.
			*/
			public final void setUpperLimit(String upperLimit)
			throws IllegalArgumentException {
			if (upperLimit == null) {
			setUpperLimit((Long) null);
			} else {
			setUpperLimit(DurationUnit.parseValue(upperLimit, baseUnit));
			}
			public static Builder createBuilder(AbstractManagedObjectDefinition<?, ?> d, String propertyName) {
			return new Builder(d, propertyName);
			}


			// Private constructor.
			private DurationPropertyDefinition(AbstractManagedObjectDefinition<?, ?> d, String propertyName,
			EnumSet<PropertyOption> options, AdministratorAction adminAction,
			DefaultBehaviorProvider<Long> defaultBehavior, DurationUnit baseUnit, DurationUnit maximumUnit,
			Long lowerLimit, Long upperLimit, boolean allowUnlimited) {
			super(d, Long.class, propertyName, options, adminAction, defaultBehavior);
			this.baseUnit = baseUnit;
			this.maximumUnit = maximumUnit;
			this.lowerLimit = lowerLimit;
			this.upperLimit = upperLimit;
			this.allowUnlimited = allowUnlimited;
			}

			/**
			* Specify whether or not this property definition will allow
			* unlimited values (default is false).
			* Get the base unit for this property definition (values including limits
			* are specified in this unit).
			*
			* @param allowUnlimited
			* <code>true</code> if the property will allow
			* unlimited values, or <code>false</code> otherwise.
			* @throws IllegalArgumentException
			* If unlimited values are to be permitted but there is
			* an upper limit specified.
			* @return Returns the base unit for this property definition (values
			* including limits are specified in this unit).
			*/
			public final void setAllowUnlimited(boolean allowUnlimited)
			throws IllegalArgumentException {
			if (allowUnlimited && upperLimit != null) {
			throw new IllegalArgumentException(
			"Upper limit specified when unlimited durations are permitted");
			}

			this.allowUnlimited = allowUnlimited;
			public DurationUnit getBaseUnit() {
			return baseUnit;
			}

			/**
			* Get the maximum unit for this property definition if specified.
			*
			* @return Returns the maximum unit for this property definition, or
			* <code>null</code> if there is no maximum unit.
			*/
			public DurationUnit getMaximumUnit() {
			return maximumUnit;
			}

			/**
			* Get the lower limit in milli-seconds.
			*
			* @return Returns the lower limit in milli-seconds.
			*/
			public long getLowerLimit() {
			return lowerLimit;
			}

			/**
			* Get the upper limit in milli-seconds.
			*
			* @return Returns the upper limit in milli-seconds, or <code>null</code> if
			* there is no upper limit.
			*/
			public Long getUpperLimit() {
			return upperLimit;
			}

			/**
			* Determine whether this property allows unlimited durations.
			*
			* @return Returns <code>true</code> if this this property allows unlimited
			* durations.
			*/
			public boolean isAllowUnlimited() {
			return allowUnlimited;
			}

			/**
			* {@inheritDoc}
			*/
			@Override
			protected DurationPropertyDefinition buildInstance(
			AbstractManagedObjectDefinition<?, ?> d, String propertyName,
			EnumSet<PropertyOption> options,
			AdministratorAction adminAction,
			DefaultBehaviorProvider<Long> defaultBehavior) {
			return new DurationPropertyDefinition(d, propertyName, options,
			adminAction, defaultBehavior, baseUnit, maximumUnit, lowerLimit,
			upperLimit, allowUnlimited);
			}
			}
			public void validateValue(Long value) throws IllegalPropertyValueException {
			ensureNotNull(value);

			long nvalue = baseUnit.toMilliSeconds(value);
			if (!allowUnlimited && nvalue < lowerLimit) {
			throw new IllegalPropertyValueException(this, value);

			// unlimited allowed
			} else if (nvalue >= 0 && nvalue < lowerLimit) {
			throw new IllegalPropertyValueException(this, value);
			}

			/**
			* Create a duration property definition builder.
			*
			* @param d
			* The managed object definition associated with this
			* property definition.
			* @param propertyName
			* The property name.
			* @return Returns the new integer property definition builder.
			*/
			public static Builder createBuilder(AbstractManagedObjectDefinition<?, ?> d,
			String propertyName) {
			return new Builder(d, propertyName);
			}



			// Private constructor.
			private DurationPropertyDefinition(AbstractManagedObjectDefinition<?, ?> d,
			String propertyName, EnumSet<PropertyOption> options,
			AdministratorAction adminAction,
			DefaultBehaviorProvider<Long> defaultBehavior, DurationUnit baseUnit,
			DurationUnit maximumUnit, Long lowerLimit, Long upperLimit,
			boolean allowUnlimited) {
			super(d, Long.class, propertyName, options, adminAction, defaultBehavior);
			this.baseUnit = baseUnit;
			this.maximumUnit = maximumUnit;
			this.lowerLimit = lowerLimit;
			this.upperLimit = upperLimit;
			this.allowUnlimited = allowUnlimited;
			}



			/**
			* Get the base unit for this property definition (values including
			* limits are specified in this unit).
			*
			* @return Returns the base unit for this property definition
			* (values including limits are specified in this unit).
			*/
			public DurationUnit getBaseUnit() {
			return baseUnit;
			}



			/**
			* Get the maximum unit for this property definition if specified.
			*
			* @return Returns the maximum unit for this property definition, or
			* <code>null</code> if there is no maximum unit.
			*/
			public DurationUnit getMaximumUnit() {
			return maximumUnit;
			}



			/**
			* Get the lower limit in milli-seconds.
			*
			* @return Returns the lower limit in milli-seconds.
			*/
			public long getLowerLimit() {
			return lowerLimit;
			}



			/**
			* Get the upper limit in milli-seconds.
			*
			* @return Returns the upper limit in milli-seconds, or
			* <code>null</code> if there is no upper limit.
			*/
			public Long getUpperLimit() {
			return upperLimit;
			}



			/**
			* Determine whether this property allows unlimited durations.
			*
			* @return Returns <code>true</code> if this this property allows
			* unlimited durations.
			*/
			public boolean isAllowUnlimited() {
			return allowUnlimited;
			}



			/**
			* {@inheritDoc}
			*/
			@Override
			public void validateValue(Long value) throws IllegalPropertyValueException {
			ensureNotNull(value);

			long nvalue = baseUnit.toMilliSeconds(value);
			if (!allowUnlimited && nvalue < lowerLimit) {
			throw new IllegalPropertyValueException(this, value);

			// unlimited allowed
			} else if (nvalue >= 0 && nvalue < lowerLimit) {
			throw new IllegalPropertyValueException(this, value);
			if ((upperLimit != null) && (nvalue > upperLimit)) {
			throw new IllegalPropertyValueException(this, value);
			}
			}

			if ((upperLimit != null) && (nvalue > upperLimit)) {
			throw new IllegalPropertyValueException(this, value);
			}
			}
			/**
			* {@inheritDoc}
			*/
			@Override
			public String encodeValue(Long value) throws IllegalPropertyValueException {
			ensureNotNull(value);

			// Make sure that we correctly encode negative values as
			// "unlimited".
			if (allowUnlimited) {
			if (value < 0) {
			return UNLIMITED;
			}
			}


			/**
			* {@inheritDoc}
			*/
			@Override
			public String encodeValue(Long value) throws IllegalPropertyValueException {
			ensureNotNull(value);

			// Make sure that we correctly encode negative values as
			// "unlimited".
			if (allowUnlimited) {
			if (value < 0) {
			return UNLIMITED;
			}
			// Encode the size value using the base unit.
			StringBuilder builder = new StringBuilder();
			builder.append(value);
			builder.append(' ');
			builder.append(baseUnit.toString());
			return builder.toString();
			}

			// Encode the size value using the base unit.
			StringBuilder builder = new StringBuilder();
			builder.append(value);
			builder.append(' ');
			builder.append(baseUnit.toString());
			return builder.toString();
			}
			/**
			* {@inheritDoc}
			*/
			@Override
			public Long decodeValue(String value) throws IllegalPropertyValueStringException {
			ensureNotNull(value);

			// First check for the special "unlimited" value when necessary.
			if (allowUnlimited) {
			if (value.trim().equalsIgnoreCase(UNLIMITED)) {
			return -1L;
			}
			}

			// Parse the string representation.
			long ms;
			try {
			ms = DurationUnit.parseValue(value);
			} catch (NumberFormatException e) {
			throw new IllegalPropertyValueStringException(this, value);
			}

			/**
			* {@inheritDoc}
			*/
			@Override
			public Long decodeValue(String value)
			throws IllegalPropertyValueStringException {
			ensureNotNull(value);
			// Check the unit is in range - values must not be more granular
			// than the base unit.
			if ((ms % baseUnit.getDuration()) != 0) {
			throw new IllegalPropertyValueStringException(this, value);
			}

			// First check for the special "unlimited" value when necessary.
			if (allowUnlimited) {
			if (value.trim().equalsIgnoreCase(UNLIMITED)) {
			return -1L;
			}
			// Convert the value a long in the property's required unit.
			Long i = (long) baseUnit.fromMilliSeconds(ms);
			try {
			validateValue(i);
			} catch (IllegalPropertyValueException e) {
			throw new IllegalPropertyValueStringException(this, value);
			}
			return i;
			}

			// Parse the string representation.
			long ms;
			try {
			ms = DurationUnit.parseValue(value);
			} catch (NumberFormatException e) {
			throw new IllegalPropertyValueStringException(this, value);
			/**
			* {@inheritDoc}
			*/
			@Override
			public <R, P> R accept(PropertyDefinitionVisitor<R, P> v, P p) {
			return v.visitDuration(this, p);
			}

			// Check the unit is in range - values must not be more granular
			// than the base unit.
			if ((ms % baseUnit.getDuration()) != 0) {
			throw new IllegalPropertyValueStringException(this, value);
			/**
			* {@inheritDoc}
			*/
			@Override
			public <R, P> R accept(PropertyValueVisitor<R, P> v, Long value, P p) {
			return v.visitDuration(this, value, p);
			}

			// Convert the value a long in the property's required unit.
			Long i = (long) baseUnit.fromMilliSeconds(ms);
			try {
			validateValue(i);
			} catch (IllegalPropertyValueException e) {
			throw new IllegalPropertyValueStringException(this, value);
			}
			return i;
			}
			/**
			* {@inheritDoc}
			*/
			@Override
			public void toString(StringBuilder builder) {
			super.toString(builder);

			builder.append(" baseUnit=");
			builder.append(baseUnit);

			if (maximumUnit != null) {
			builder.append(" maximumUnit=");
			builder.append(maximumUnit);
			}

			/**
			* {@inheritDoc}
			*/
			@Override
			public <R, P> R accept(PropertyDefinitionVisitor<R, P> v, P p) {
			return v.visitDuration(this, p);
			}
			builder.append(" lowerLimit=");
			builder.append(lowerLimit);
			builder.append("ms");

			if (upperLimit != null) {
			builder.append(" upperLimit=");
			builder.append(upperLimit);
			builder.append("ms");
			}


			/**
			* {@inheritDoc}
			*/
			@Override
			public <R, P> R accept(PropertyValueVisitor<R, P> v, Long value, P p) {
			return v.visitDuration(this, value, p);
			}



			/**
			* {@inheritDoc}
			*/
			@Override
			public void toString(StringBuilder builder) {
			super.toString(builder);

			builder.append(" baseUnit=");
			builder.append(baseUnit);

			if (maximumUnit != null) {
			builder.append(" maximumUnit=");
			builder.append(maximumUnit);
			builder.append(" allowUnlimited=");
			builder.append(allowUnlimited);
			}

			builder.append(" lowerLimit=");
			builder.append(lowerLimit);
			builder.append("ms");

			if (upperLimit != null) {
			builder.append(" upperLimit=");
			builder.append(upperLimit);
			builder.append("ms");
			/**
			* {@inheritDoc}
			*/
			@Override
			public int compare(Long o1, Long o2) {
			return o1.compareTo(o2);
			}

			builder.append(" allowUnlimited=");
			builder.append(allowUnlimited);
			}



			/**
			* {@inheritDoc}
			*/
			@Override
			public int compare(Long o1, Long o2) {
			return o1.compareTo(o2);
			}

			}