/*
* 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
*
*
* Copyright 2008 Sun Microsystems, Inc.
*/
package org.opends.server.admin.client.spi;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;
import org.opends.server.admin.IllegalPropertyValueException;
import org.opends.server.admin.PropertyDefinition;
import org.opends.server.admin.PropertyIsMandatoryException;
import org.opends.server.admin.PropertyIsSingleValuedException;
import org.opends.server.admin.PropertyOption;
/**
* A set of properties. Instances of this class can be used as the
* core of a managed object implementation.
*/
public final class PropertySet {
/**
* Internal property implementation.
*
* @param <T>
* The type of the property.
*/
private static final class MyProperty<T> implements Property<T> {
// The active set of values.
private final SortedSet<T> activeValues;
// The definition associated with this property.
private final PropertyDefinition<T> d;
// The default set of values (read-only).
private final SortedSet<T> defaultValues;
// The pending set of values.
private final SortedSet<T> pendingValues;
/**
* Create a property with the provided sets of pre-validated
* default and active values.
*
* @param pd
* 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> pd, Collection<T> defaultValues,
Collection<T> activeValues) {
this.d = pd;
SortedSet<T> sortedDefaultValues = new TreeSet<T>(pd);
sortedDefaultValues.addAll(defaultValues);
this.defaultValues = Collections
.unmodifiableSortedSet(sortedDefaultValues);
this.activeValues = new TreeSet<T>(pd);
this.activeValues.addAll(activeValues);
// Initially the pending values is the same as the active
// values.
this.pendingValues = new TreeSet<T>(this.activeValues);
}
/**
* Makes the pending values active.
*/
public void commit() {
activeValues.clear();
activeValues.addAll(pendingValues);
}
/**
* {@inheritDoc}
*/
public SortedSet<T> getActiveValues() {
return Collections.unmodifiableSortedSet(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.size() == pendingValues.size()
&& activeValues.containsAll(pendingValues)) {
return false;
}
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}
*/
@Override
public String toString() {
return getEffectiveValues().toString();
}
/**
* {@inheritDoc}
*/
public boolean wasEmpty() {
return activeValues.isEmpty();
}
}
// The properties.
private final Map<PropertyDefinition<?>, MyProperty<?>> properties;
/**
* Creates a new empty property set.
*/
public PropertySet() {
this.properties = new HashMap<PropertyDefinition<?>, MyProperty<?>>();
}
/**
* Creates a property with the provided sets of pre-validated
* default and active values.
*
* @param <T>
* The type of the property.
* @param pd
* The property definition.
* @param defaultValues
* The set of default values for the property.
* @param activeValues
* The set of active values for the property.
*/
public <T> void addProperty(PropertyDefinition<T> pd,
Collection<T> defaultValues, Collection<T> activeValues) {
MyProperty<T> p = new MyProperty<T>(pd, defaultValues, activeValues);
properties.put(pd, p);
}
/**
* 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 (Property<T>) properties.get(d);
}
/**
* {@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();
}
/**
* Makes all pending values active.
*/
void commit() {
for (MyProperty<?> p : properties.values()) {
p.commit();
}
}
/**
* 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 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.
*/
<T> void setPropertyValues(PropertyDefinition<T> d,
Collection<T> values) throws IllegalPropertyValueException,
PropertyIsSingleValuedException, PropertyIsMandatoryException,
IllegalArgumentException {
MyProperty<T> property = (MyProperty<T>) getProperty(d);
if (values.size() > 1 && !d.hasOption(PropertyOption.MULTI_VALUED)) {
throw new PropertyIsSingleValuedException(d);
}
if (values.isEmpty() && d.hasOption(PropertyOption.MANDATORY)) {
// But only if there are no default values.
if (property.getDefaultValues().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);
}
}