001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2008 Sun Microsystems, Inc.
026 */
027
028 package org.opends.server.admin;
029 import org.opends.messages.Message;
030
031
032
033 import static org.opends.server.util.Validator.*;
034
035 import java.util.Collections;
036 import java.util.HashMap;
037 import java.util.Locale;
038 import java.util.Map;
039 import java.util.Set;
040
041
042
043 /**
044 * A managed object composite relationship definition which represents
045 * a composition of zero or more managed objects.
046 *
047 * @param <C>
048 * The type of client managed object configuration that this
049 * relation definition refers to.
050 * @param <S>
051 * The type of server managed object configuration that this
052 * relation definition refers to.
053 */
054 public final class InstantiableRelationDefinition
055 <C extends ConfigurationClient, S extends Configuration>
056 extends RelationDefinition<C, S> {
057
058 /**
059 * An interface for incrementally constructing instantiable relation
060 * definitions.
061 *
062 * @param <C>
063 * The type of client managed object configuration that
064 * this relation definition refers to.
065 * @param <S>
066 * The type of server managed object configuration that
067 * this relation definition refers to.
068 */
069 public static final class Builder
070 <C extends ConfigurationClient, S extends Configuration>
071 extends AbstractBuilder<C, S, InstantiableRelationDefinition<C, S>> {
072
073 // The optional naming property definition.
074 private PropertyDefinition<?> namingPropertyDefinition = null;
075
076 // The plural name of the relation.
077 private final String pluralName;
078
079 // The optional default managed objects associated with this
080 // instantiable relation definition.
081 private final Map<String, DefaultManagedObject<? extends C, ? extends S>>
082 defaultManagedObjects = new HashMap<String,
083 DefaultManagedObject<? extends C, ? extends S>>();
084
085
086 /**
087 * Creates a new builder which can be used to incrementally build
088 * an instantiable relation definition.
089 *
090 * @param pd
091 * The parent managed object definition.
092 * @param name
093 * The name of the relation.
094 * @param pluralName
095 * The plural name of the relation.
096 * @param cd
097 * The child managed object definition.
098 */
099 public Builder(AbstractManagedObjectDefinition<?, ?> pd, String name,
100 String pluralName, AbstractManagedObjectDefinition<C, S> cd) {
101 super(pd, name, cd);
102 this.pluralName = pluralName;
103 }
104
105
106
107 /**
108 * Adds the named default managed object to this instantiable
109 * relation definition.
110 *
111 * @param name
112 * The name of the default managed object.
113 * @param defaultManagedObject
114 * The default managed object.
115 */
116 public void setDefaultManagedObject(String name,
117 DefaultManagedObject<? extends C, ? extends S> defaultManagedObject) {
118 this.defaultManagedObjects.put(name, defaultManagedObject);
119 }
120
121
122
123 /**
124 * Sets the naming property for the instantiable relation
125 * definition.
126 *
127 * @param namingPropertyDefinition
128 * The property of the child managed object definition
129 * which should be used for naming, or <code>null</code>
130 * if this relation does not use a property for naming.
131 */
132 public void setNamingProperty(
133 PropertyDefinition<?> namingPropertyDefinition) {
134 ensureNotNull(namingPropertyDefinition);
135 this.namingPropertyDefinition = namingPropertyDefinition;
136 }
137
138
139
140 /**
141 * {@inheritDoc}
142 */
143 @Override
144 protected InstantiableRelationDefinition<C, S> buildInstance(
145 Common<C, S> common) {
146 return new InstantiableRelationDefinition<C, S>(common, pluralName,
147 namingPropertyDefinition, defaultManagedObjects);
148 }
149
150 }
151
152 // The optional naming property definition.
153 private final PropertyDefinition<?> namingPropertyDefinition;
154
155 // The plural name of the relation.
156 private final String pluralName;
157
158 // The optional default managed objects associated with this
159 // instantiable relation definition.
160 private final Map<String, DefaultManagedObject<? extends C, ? extends S>>
161 defaultManagedObjects;
162
163
164
165 // Private constructor.
166 private InstantiableRelationDefinition(Common<C, S> common,
167 String pluralName,
168 PropertyDefinition<?> namingPropertyDefinition,
169 Map<String, DefaultManagedObject<? extends C, ? extends S>>
170 defaultManagedObjects) {
171 super(common);
172 this.pluralName = pluralName;
173 this.namingPropertyDefinition = namingPropertyDefinition;
174 this.defaultManagedObjects = defaultManagedObjects;
175 }
176
177
178
179 /**
180 * {@inheritDoc}
181 */
182 @Override
183 public <R, P> R accept(RelationDefinitionVisitor<R, P> v, P p) {
184 return v.visitInstantiable(this, p);
185 }
186
187
188
189 /**
190 * Gets the named default managed object associated with this
191 * instantiable relation definition.
192 *
193 * @param name
194 * The name of the default managed object.
195 * @return Returns the named default managed object.
196 * @throws IllegalArgumentException
197 * If there is no default managed object associated with
198 * the provided name.
199 */
200 public DefaultManagedObject<? extends C, ? extends S> getDefaultManagedObject(
201 String name) throws IllegalArgumentException {
202 if (!defaultManagedObjects.containsKey(name)) {
203 throw new IllegalArgumentException(
204 "unrecognized default managed object \"" + name + "\"");
205 }
206 return defaultManagedObjects.get(name);
207 }
208
209
210
211 /**
212 * Gets the names of the default managed objects associated with
213 * this instantiable relation definition.
214 *
215 * @return Returns an unmodifiable set containing the names of the
216 * default managed object.
217 */
218 public Set<String> getDefaultManagedObjectNames() {
219 return Collections.unmodifiableSet(defaultManagedObjects.keySet());
220 }
221
222
223
224 /**
225 * Get the property of the child managed object definition which
226 * should be used for naming children.
227 *
228 * @return Returns the property of the child managed object
229 * definition which should be used for naming, or
230 * <code>null</code> if this relation does not use a
231 * property for naming.
232 */
233 public PropertyDefinition<?> getNamingPropertyDefinition() {
234 return namingPropertyDefinition;
235 }
236
237
238
239 /**
240 * Get the plural name of the relation.
241 *
242 * @return Returns the plural name of the relation.
243 */
244 public String getPluralName() {
245 return pluralName;
246 }
247
248
249
250 /**
251 * Gets the user friendly plural name of this relation definition in
252 * the default locale.
253 *
254 * @return Returns the user friendly plural name of this relation
255 * definition in the default locale.
256 */
257 public Message getUserFriendlyPluralName() {
258 return getUserFriendlyPluralName(Locale.getDefault());
259 }
260
261
262
263 /**
264 * Gets the user friendly plural name of this relation definition in
265 * the specified locale.
266 *
267 * @param locale
268 * The locale.
269 * @return Returns the user friendly plural name of this relation
270 * definition in the specified locale.
271 */
272 public Message getUserFriendlyPluralName(Locale locale) {
273 String property = "relation." + getName() + ".user-friendly-plural-name";
274 return ManagedObjectDefinitionI18NResource.getInstance().getMessage(
275 getParentDefinition(), property, locale);
276 }
277
278
279
280 /**
281 * {@inheritDoc}
282 */
283 @Override
284 public void toString(StringBuilder builder) {
285 builder.append("name=");
286 builder.append(getName());
287 builder.append(" type=composition parent=");
288 builder.append(getParentDefinition().getName());
289 builder.append(" child=");
290 builder.append(getChildDefinition().getName());
291 builder.append(" child=");
292 builder.append(getChildDefinition().getName());
293 builder.append(" minOccurs=0");
294 }
295
296
297
298 /**
299 * {@inheritDoc}
300 */
301 @Override
302 protected void initialize() throws Exception {
303 for (DefaultManagedObject<?, ?> dmo : defaultManagedObjects.values()) {
304 dmo.initialize();
305 }
306 }
307 }