/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions Copyright 2007 Sun Microsystems, Inc.
|
*/
|
|
package org.opends.server.admin.client;
|
|
|
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.SortedSet;
|
import java.util.TreeSet;
|
|
import org.opends.server.admin.AbsoluteInheritedDefaultBehaviorProvider;
|
import org.opends.server.admin.AliasDefaultBehaviorProvider;
|
import org.opends.server.admin.DefaultBehaviorPropertyValueException;
|
import org.opends.server.admin.DefaultBehaviorProviderVisitor;
|
import org.opends.server.admin.DefinedDefaultBehaviorProvider;
|
import org.opends.server.admin.IllegalPropertyValueException;
|
import org.opends.server.admin.IllegalPropertyValueStringException;
|
import org.opends.server.admin.InheritedDefaultValueException;
|
import org.opends.server.admin.InheritedDefaultValueProvider;
|
import org.opends.server.admin.ManagedObjectDefinition;
|
import org.opends.server.admin.ManagedObjectPath;
|
import org.opends.server.admin.OperationsException;
|
import org.opends.server.admin.PropertyDefinition;
|
import org.opends.server.admin.PropertyException;
|
import org.opends.server.admin.PropertyIsMandatoryException;
|
import org.opends.server.admin.PropertyIsReadOnlyException;
|
import org.opends.server.admin.PropertyIsSingleValuedException;
|
import org.opends.server.admin.PropertyOption;
|
import org.opends.server.admin.PropertyProvider;
|
import org.opends.server.admin.RelativeInheritedDefaultBehaviorProvider;
|
import org.opends.server.admin.StringPropertyProvider;
|
import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
|
|
|
|
/**
|
* A set of properties. Instances of this class can be used as the core of a
|
* managed object implementation.
|
*/
|
public final class PropertySet implements PropertyProvider {
|
|
/**
|
* Internal property implementation.
|
*
|
* @param <T>
|
* The type of the property.
|
*/
|
private static final class MyProperty<T> implements Property<T> {
|
|
// The definition associated with this property.
|
private final PropertyDefinition<T> d;
|
|
// The default set of values (read-only).
|
private final SortedSet<T> defaultValues;
|
|
// The active set of values (read-only).
|
private final SortedSet<T> activeValues;
|
|
// The pending set of values.
|
private final SortedSet<T> pendingValues;
|
|
|
|
/**
|
* Create a property with the provided sets of pre-validated default and
|
* active values.
|
* <p>
|
* This constructor takes ownership of the provided value sets.
|
*
|
* @param d
|
* The property definition.
|
* @param defaultValues
|
* The set of default values for the property.
|
* @param activeValues
|
* The set of active values for the property.
|
*/
|
public MyProperty(PropertyDefinition<T> d, SortedSet<T> defaultValues,
|
SortedSet<T> activeValues) {
|
this.d = d;
|
this.defaultValues = Collections.unmodifiableSortedSet(defaultValues);
|
this.activeValues = Collections.unmodifiableSortedSet(activeValues);
|
|
// Initially the pending values is the same as the active values.
|
this.pendingValues = new TreeSet<T>(this.activeValues);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> getActiveValues() {
|
return activeValues;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> getDefaultValues() {
|
return defaultValues;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> getEffectiveValues() {
|
SortedSet<T> values = getPendingValues();
|
|
if (values.isEmpty()) {
|
values = getDefaultValues();
|
}
|
|
return values;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> getPendingValues() {
|
return Collections.unmodifiableSortedSet(pendingValues);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public PropertyDefinition<T> getPropertyDefinition() {
|
return d;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean isEmpty() {
|
return pendingValues.isEmpty();
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean isModified() {
|
if (activeValues == pendingValues) {
|
return false;
|
} else if (activeValues.size() != pendingValues.size()) {
|
return true;
|
} else if (activeValues.containsAll(pendingValues)) {
|
return false;
|
} else {
|
return true;
|
}
|
}
|
|
|
|
/**
|
* Replace all pending values of this property with the provided values.
|
*
|
* @param c
|
* The new set of pending property values.
|
*/
|
public void setPendingValues(Collection<T> c) {
|
pendingValues.clear();
|
pendingValues.addAll(c);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean wasEmpty() {
|
return activeValues.isEmpty();
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public String toString() {
|
return getEffectiveValues().toString();
|
}
|
}
|
|
|
|
/**
|
* Internal default behavior visitor implementation.
|
*
|
* @param <T>
|
* The type of the default property values.
|
*/
|
private static final class DefaultVisitor<T> implements
|
DefaultBehaviorProviderVisitor<T, SortedSet<T>,
|
Collection<PropertyException>> {
|
|
// The property definition.
|
private final PropertyDefinition<T> pd;
|
|
// Used to retrieve inherited properties.
|
private final InheritedDefaultValueProvider provider;
|
|
|
|
// Private constructor.
|
private DefaultVisitor(PropertyDefinition<T> pd,
|
InheritedDefaultValueProvider provider) {
|
this.pd = pd;
|
this.provider = provider;
|
}
|
|
|
|
// Cast a set of objects to the required type.
|
private Collection<T> castValues(Collection<?> values,
|
Collection<PropertyException> exceptions) {
|
List<T> castValues = new LinkedList<T>();
|
for (Object value : values) {
|
try {
|
castValues.add(pd.castValue(value));
|
} catch (ClassCastException e) {
|
exceptions.add(new IllegalPropertyValueException(pd, value));
|
}
|
}
|
return castValues;
|
}
|
|
|
|
// Build set of default values and validate them.
|
private SortedSet<T> validateStrings(Collection<String> values,
|
Collection<PropertyException> exceptions) {
|
TreeSet<T> defaultValues = new TreeSet<T>(pd);
|
for (String value : values) {
|
try {
|
defaultValues.add(pd.decodeValue(value));
|
} catch (IllegalPropertyValueStringException e) {
|
exceptions.add(new DefaultBehaviorPropertyValueException(pd, e));
|
}
|
}
|
|
if (!pd.hasOption(PropertyOption.MULTI_VALUED)) {
|
if (defaultValues.size() > 1) {
|
PropertyException e = new PropertyIsSingleValuedException(pd);
|
exceptions.add(new DefaultBehaviorPropertyValueException(pd, e));
|
}
|
}
|
|
return defaultValues;
|
}
|
|
|
|
// Build set of default values and validate them.
|
private SortedSet<T> validate(Collection<T> values,
|
Collection<PropertyException> exceptions) {
|
TreeSet<T> defaultValues = new TreeSet<T>(pd);
|
for (T value : values) {
|
try {
|
pd.validateValue(value);
|
defaultValues.add(value);
|
} catch (IllegalPropertyValueException e) {
|
exceptions.add(new DefaultBehaviorPropertyValueException(pd, e));
|
}
|
}
|
|
if (!pd.hasOption(PropertyOption.MULTI_VALUED)) {
|
if (defaultValues.size() > 1) {
|
PropertyException e = new PropertyIsSingleValuedException(pd);
|
exceptions.add(new DefaultBehaviorPropertyValueException(pd, e));
|
}
|
}
|
|
return defaultValues;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> visitAbsoluteInherited(
|
AbsoluteInheritedDefaultBehaviorProvider<T> d,
|
Collection<PropertyException> p) {
|
// Get the values from the managed object at the specified path.
|
try {
|
// Get the property values/defaults.
|
ManagedObjectPath path = d.getManagedObjectPath();
|
Collection<?> values = provider.getDefaultPropertyValues(path, d
|
.getPropertyName());
|
return validate(castValues(values, p), p);
|
} catch (OperationsException e) {
|
p.add(new InheritedDefaultValueException(pd, e));
|
return new TreeSet<T>(pd);
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> visitAlias(AliasDefaultBehaviorProvider<T> d,
|
Collection<PropertyException> p) {
|
// No values applicable - just return the empty set.
|
return new TreeSet<T>(pd);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> visitDefined(DefinedDefaultBehaviorProvider<T> d,
|
Collection<PropertyException> p) {
|
return validateStrings(d.getDefaultValues(), p);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> visitRelativeInherited(
|
RelativeInheritedDefaultBehaviorProvider<T> d,
|
Collection<PropertyException> p) {
|
if (d.getRelativeOffset() == 0) {
|
// TODO: we're inheriting default values from another property in this
|
// property set. Logging is a good use-case: there is a general logging
|
// level for all categories and then category specific levels which can
|
// override. Should the default values be determined dynamically every
|
// time they are accessed? If dynamically, how will decoding errors be
|
// handled? Dynamically: we could return a SortedSet<T> which is lazily
|
// computed.
|
return new TreeSet<T>(pd);
|
} else {
|
// Inheriting default values from a parent managed object.
|
try {
|
ManagedObjectPath base = provider.getManagedObjectPath();
|
ManagedObjectPath path = d.getManagedObjectPath(base);
|
Collection<?> values = provider.getDefaultPropertyValues(path, d
|
.getPropertyName());
|
return validate(castValues(values, p), p);
|
} catch (OperationsException e) {
|
p.add(new InheritedDefaultValueException(pd, e));
|
return new TreeSet<T>(pd);
|
}
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public SortedSet<T> visitUndefined(UndefinedDefaultBehaviorProvider<T> d,
|
Collection<PropertyException> p) {
|
// No values applicable - just return the empty set.
|
return new TreeSet<T>(pd);
|
}
|
}
|
|
|
|
/**
|
* Create a new property set using a property provider to supply the active
|
* property values. This constructor takes care of validation of the property
|
* values and retrieval of any default values.
|
* <p>
|
* Any exceptions that occurred whilst processing the properties will be
|
* placed in the provided exception collection. Properties that caused the
|
* exceptions will be created with an empty set of values (note that this
|
* could mean that the resulting property set might contain empty mandatory
|
* properties).
|
*
|
* @param d
|
* The managed object definition.
|
* @param p
|
* The property provider.
|
* @param i
|
* An inherited managed object provider for retrieving inherited
|
* properties.
|
* @param exceptions
|
* A collection in which any property exceptions can be placed.
|
* @return Returns the new property set.
|
*/
|
public static PropertySet create(ManagedObjectDefinition<?, ?> d,
|
PropertyProvider p, InheritedDefaultValueProvider i,
|
Collection<PropertyException> exceptions) {
|
Map<PropertyDefinition, MyProperty> properties =
|
new HashMap<PropertyDefinition, MyProperty>();
|
|
// Copy the properties from the provider.
|
for (PropertyDefinition<?> pd : d.getPropertyDefinitions()) {
|
createProperty(pd, p, i, properties, exceptions);
|
}
|
|
return new PropertySet(properties);
|
}
|
|
|
|
/**
|
* Create a new property set using a string property provider to supply the
|
* active property values. This constructor takes care of validation of the
|
* property values and retrieval of any default values.
|
* <p>
|
* Any exceptions that occurred whilst processing the properties will be
|
* placed in the provided exception collection. Properties that caused the
|
* exceptions will be created with an empty set of values (note that this
|
* could mean that the resulting property set might contain empty mandatory
|
* properties).
|
*
|
* @param d
|
* The managed object definition.
|
* @param p
|
* The string property provider.
|
* @param i
|
* An inherited managed object provider for retrieving inherited
|
* properties.
|
* @param exceptions
|
* A collection in which any property exceptions can be placed.
|
* @return Returns the new property set.
|
*/
|
public static PropertySet create(ManagedObjectDefinition<?, ?> d,
|
StringPropertyProvider p, InheritedDefaultValueProvider i,
|
Collection<PropertyException> exceptions) {
|
Map<PropertyDefinition, MyProperty> properties =
|
new HashMap<PropertyDefinition, MyProperty>();
|
|
// Copy the properties from the provider.
|
for (PropertyDefinition<?> pd : d.getPropertyDefinitions()) {
|
createProperty(pd, p, i, properties, exceptions);
|
}
|
|
return new PropertySet(properties);
|
}
|
|
|
|
// Create new property using string values taken from a property provider.
|
private static <T> void createProperty(PropertyDefinition<T> pd,
|
StringPropertyProvider p, InheritedDefaultValueProvider i,
|
Map<PropertyDefinition, MyProperty> properties,
|
Collection<PropertyException> exceptions) {
|
|
// Get the active values for this property.
|
Collection<String> activeStringValues;
|
|
try {
|
activeStringValues = p.getPropertyValues(pd);
|
} catch (IllegalArgumentException e) {
|
// Default to empty set of values.
|
activeStringValues = Collections.<String> emptySet();
|
}
|
|
SortedSet<T> activeValues = new TreeSet<T>(pd);
|
boolean gotException = false;
|
for (String stringValue : activeStringValues) {
|
try {
|
activeValues.add(pd.decodeValue(stringValue));
|
} catch (IllegalPropertyValueStringException e) {
|
exceptions.add(e);
|
gotException = true;
|
}
|
}
|
|
if (gotException == false) {
|
if (pd.hasOption(PropertyOption.MANDATORY)) {
|
if (activeValues.isEmpty()) {
|
exceptions.add(new PropertyIsMandatoryException(pd));
|
}
|
}
|
}
|
|
createProperty(pd, activeValues, i, properties, exceptions);
|
}
|
|
|
|
// Create new property using values taken from a property provider.
|
private static <T> void createProperty(PropertyDefinition<T> pd,
|
PropertyProvider p, InheritedDefaultValueProvider i,
|
Map<PropertyDefinition, MyProperty> properties,
|
Collection<PropertyException> exceptions) {
|
// Get the active values for this property.
|
Collection<T> activeValues;
|
|
try {
|
activeValues = p.getPropertyValues(pd);
|
} catch (IllegalArgumentException e) {
|
// Default to empty set of values.
|
activeValues = Collections.<T> emptySet();
|
}
|
|
SortedSet<T> validActiveValues = new TreeSet<T>(pd);
|
boolean gotException = false;
|
for (T value : activeValues) {
|
try {
|
pd.validateValue(value);
|
validActiveValues.add(value);
|
} catch (IllegalPropertyValueException e) {
|
exceptions.add(e);
|
gotException = true;
|
}
|
}
|
|
if (gotException == false) {
|
if (pd.hasOption(PropertyOption.MANDATORY)) {
|
if (validActiveValues.isEmpty()) {
|
exceptions.add(new PropertyIsMandatoryException(pd));
|
}
|
}
|
}
|
|
createProperty(pd, validActiveValues, i, properties, exceptions);
|
}
|
|
|
|
// Create new property using the provided validated values.
|
private static <T> void createProperty(PropertyDefinition<T> pd,
|
SortedSet<T> activeValues, InheritedDefaultValueProvider i,
|
Map<PropertyDefinition, MyProperty> properties,
|
Collection<PropertyException> exceptions) {
|
// Do remaining validation of active values.
|
if (!pd.hasOption(PropertyOption.MULTI_VALUED)) {
|
if (activeValues.size() > 1) {
|
exceptions.add(new PropertyIsSingleValuedException(pd));
|
}
|
}
|
|
// Get the default values for this property.
|
DefaultVisitor<T> visitor = new DefaultVisitor<T>(pd, i);
|
SortedSet<T> defaultValues = pd.getDefaultBehaviorProvider().accept(
|
visitor, exceptions);
|
|
// Create the property.
|
properties.put(pd, new MyProperty<T>(pd, defaultValues, activeValues));
|
}
|
|
// The properties.
|
private final Map<PropertyDefinition, MyProperty> properties;
|
|
|
|
// Private constructor.
|
private PropertySet(Map<PropertyDefinition, MyProperty> properties) {
|
this.properties = properties;
|
}
|
|
|
|
/**
|
* Get the property associated with the specified property definition.
|
*
|
* @param <T>
|
* The underlying type of the property.
|
* @param d
|
* The Property definition.
|
* @return Returns the property associated with the specified property
|
* definition.
|
* @throws IllegalArgumentException
|
* If this property provider does not recognise the requested
|
* property definition.
|
*/
|
@SuppressWarnings("unchecked")
|
public <T> Property<T> getProperty(PropertyDefinition<T> d)
|
throws IllegalArgumentException {
|
if (!properties.containsKey(d)) {
|
throw new IllegalArgumentException("Unknown property " + d.getName());
|
}
|
|
return properties.get(d);
|
}
|
|
|
|
/**
|
* Get the effective value of the specified property.
|
* <p>
|
* See the class description for more information about how the effective
|
* property value is derived.
|
*
|
* @param <T>
|
* The type of the property to be retrieved.
|
* @param d
|
* The property to be retrieved.
|
* @return Returns the property's effective value, or <code>null</code> if
|
* there is no effective value defined.
|
* @throws IllegalArgumentException
|
* If the property definition is not associated with this managed
|
* object's definition.
|
*/
|
public <T> T getPropertyValue(PropertyDefinition<T> d)
|
throws IllegalArgumentException {
|
Set<T> values = getPropertyValues(d);
|
if (values.isEmpty()) {
|
return null;
|
} else {
|
return values.iterator().next();
|
}
|
}
|
|
|
|
/**
|
* Get the effective values of the specified property.
|
* <p>
|
* See the class description for more information about how the effective
|
* property values are derived.
|
*
|
* @param <T>
|
* The type of the property to be retrieved.
|
* @param d
|
* The property to be retrieved.
|
* @return Returns the property's effective values, or an empty set if there
|
* are no effective values defined.
|
* @throws IllegalArgumentException
|
* If the property definition is not associated with this managed
|
* object's definition.
|
*/
|
public <T> SortedSet<T> getPropertyValues(PropertyDefinition<T> d)
|
throws IllegalArgumentException {
|
Property<T> property = getProperty(d);
|
return new TreeSet<T>(property.getEffectiveValues());
|
}
|
|
|
|
/**
|
* Set a new pending value for the specified property.
|
* <p>
|
* See the class description for more information regarding pending values.
|
*
|
* @param <T>
|
* The type of the property to be modified.
|
* @param d
|
* The property to be modified.
|
* @param value
|
* The new pending value for the property, or <code>null</code> if
|
* the property should be reset to its default behavior.
|
* @throws IllegalPropertyValueException
|
* If the new pending value is deemed to be invalid according to the
|
* property definition.
|
* @throws PropertyIsReadOnlyException
|
* If an attempt was made to modify a read-only property.
|
* @throws PropertyIsMandatoryException
|
* If an attempt was made to remove a mandatory property.
|
* @throws IllegalArgumentException
|
* If the specified property definition is not associated with this
|
* managed object, or if the property is read-only.
|
*/
|
public <T> void setPropertyValue(PropertyDefinition<T> d, T value)
|
throws IllegalPropertyValueException, PropertyIsReadOnlyException,
|
PropertyIsMandatoryException, IllegalArgumentException {
|
if (value == null) {
|
setPropertyValues(d, Collections.<T> emptySet());
|
} else {
|
setPropertyValues(d, Collections.singleton(value));
|
}
|
}
|
|
|
|
/**
|
* Set a new pending values for the specified property.
|
* <p>
|
* See the class description for more information regarding pending values.
|
*
|
* @param <T>
|
* The type of the property to be modified.
|
* @param d
|
* The property to be modified.
|
* @param values
|
* A non-<code>null</code> set of new pending values for the
|
* property (an empty set indicates that the property should be reset
|
* to its default behavior). The set will not be referenced by this
|
* managed object.
|
* @throws IllegalPropertyValueException
|
* If a new pending value is deemed to be invalid according to the
|
* property definition.
|
* @throws PropertyIsSingleValuedException
|
* If an attempt was made to add multiple pending values to a
|
* single-valued property.
|
* @throws PropertyIsReadOnlyException
|
* If an attempt was made to modify a read-only property.
|
* @throws PropertyIsMandatoryException
|
* If an attempt was made to remove a mandatory property.
|
* @throws IllegalArgumentException
|
* If the specified property definition is not associated with this
|
* managed object, or if the property is read-only.
|
*/
|
public <T> void setPropertyValues(PropertyDefinition<T> d,
|
Collection<T> values) throws IllegalPropertyValueException,
|
PropertyIsSingleValuedException, PropertyIsReadOnlyException,
|
PropertyIsMandatoryException, IllegalArgumentException {
|
MyProperty<T> property = (MyProperty<T>) getProperty(d);
|
|
if (d.hasOption(PropertyOption.READ_ONLY)) {
|
throw new PropertyIsReadOnlyException(d);
|
}
|
|
if (!d.hasOption(PropertyOption.MULTI_VALUED)) {
|
if (values.size() > 1) {
|
throw new PropertyIsSingleValuedException(d);
|
}
|
}
|
|
if (d.hasOption(PropertyOption.MANDATORY)) {
|
if (values.isEmpty()) {
|
throw new PropertyIsMandatoryException(d);
|
}
|
}
|
|
// Validate each value.
|
for (T e : values) {
|
if (e == null) {
|
throw new NullPointerException();
|
}
|
|
d.validateValue(e);
|
}
|
|
// Update the property.
|
property.setPendingValues(values);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public String toString() {
|
StringBuilder builder = new StringBuilder();
|
builder.append('{');
|
for (Map.Entry<PropertyDefinition, MyProperty> entry : properties
|
.entrySet()) {
|
builder.append(entry.getKey().getName());
|
builder.append('=');
|
builder.append(entry.getValue().toString());
|
builder.append(' ');
|
}
|
builder.append('}');
|
return builder.toString();
|
}
|
}
|
