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    package org.opends.server.admin.std.meta;
028    
029    
030    
031    import java.util.Collection;
032    import org.opends.server.admin.client.AuthorizationException;
033    import org.opends.server.admin.client.CommunicationException;
034    import org.opends.server.admin.client.ConcurrentModificationException;
035    import org.opends.server.admin.client.IllegalManagedObjectNameException;
036    import org.opends.server.admin.client.ManagedObject;
037    import org.opends.server.admin.client.ManagedObjectDecodingException;
038    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
039    import org.opends.server.admin.client.OperationRejectedException;
040    import org.opends.server.admin.DefaultBehaviorException;
041    import org.opends.server.admin.DefinitionDecodingException;
042    import org.opends.server.admin.InstantiableRelationDefinition;
043    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
044    import org.opends.server.admin.ManagedObjectDefinition;
045    import org.opends.server.admin.ManagedObjectNotFoundException;
046    import org.opends.server.admin.PropertyProvider;
047    import org.opends.server.admin.RelationOption;
048    import org.opends.server.admin.server.ConfigurationAddListener;
049    import org.opends.server.admin.server.ConfigurationDeleteListener;
050    import org.opends.server.admin.server.ServerManagedObject;
051    import org.opends.server.admin.SingletonRelationDefinition;
052    import org.opends.server.admin.std.client.AccessControlHandlerCfgClient;
053    import org.opends.server.admin.std.client.AccountStatusNotificationHandlerCfgClient;
054    import org.opends.server.admin.std.client.AlertHandlerCfgClient;
055    import org.opends.server.admin.std.client.AttributeSyntaxCfgClient;
056    import org.opends.server.admin.std.client.BackendCfgClient;
057    import org.opends.server.admin.std.client.CertificateMapperCfgClient;
058    import org.opends.server.admin.std.client.ConnectionHandlerCfgClient;
059    import org.opends.server.admin.std.client.CryptoManagerCfgClient;
060    import org.opends.server.admin.std.client.EntryCacheCfgClient;
061    import org.opends.server.admin.std.client.ExtendedOperationHandlerCfgClient;
062    import org.opends.server.admin.std.client.GlobalCfgClient;
063    import org.opends.server.admin.std.client.GroupImplementationCfgClient;
064    import org.opends.server.admin.std.client.IdentityMapperCfgClient;
065    import org.opends.server.admin.std.client.KeyManagerProviderCfgClient;
066    import org.opends.server.admin.std.client.LogPublisherCfgClient;
067    import org.opends.server.admin.std.client.LogRetentionPolicyCfgClient;
068    import org.opends.server.admin.std.client.LogRotationPolicyCfgClient;
069    import org.opends.server.admin.std.client.MatchingRuleCfgClient;
070    import org.opends.server.admin.std.client.MonitorProviderCfgClient;
071    import org.opends.server.admin.std.client.NetworkGroupCfgClient;
072    import org.opends.server.admin.std.client.PasswordGeneratorCfgClient;
073    import org.opends.server.admin.std.client.PasswordPolicyCfgClient;
074    import org.opends.server.admin.std.client.PasswordStorageSchemeCfgClient;
075    import org.opends.server.admin.std.client.PasswordValidatorCfgClient;
076    import org.opends.server.admin.std.client.PluginRootCfgClient;
077    import org.opends.server.admin.std.client.RootCfgClient;
078    import org.opends.server.admin.std.client.RootDNCfgClient;
079    import org.opends.server.admin.std.client.RootDSEBackendCfgClient;
080    import org.opends.server.admin.std.client.SASLMechanismHandlerCfgClient;
081    import org.opends.server.admin.std.client.SynchronizationProviderCfgClient;
082    import org.opends.server.admin.std.client.TrustManagerProviderCfgClient;
083    import org.opends.server.admin.std.client.VirtualAttributeCfgClient;
084    import org.opends.server.admin.std.client.WorkflowCfgClient;
085    import org.opends.server.admin.std.client.WorkflowElementCfgClient;
086    import org.opends.server.admin.std.client.WorkQueueCfgClient;
087    import org.opends.server.admin.std.server.AccessControlHandlerCfg;
088    import org.opends.server.admin.std.server.AccountStatusNotificationHandlerCfg;
089    import org.opends.server.admin.std.server.AlertHandlerCfg;
090    import org.opends.server.admin.std.server.AttributeSyntaxCfg;
091    import org.opends.server.admin.std.server.BackendCfg;
092    import org.opends.server.admin.std.server.CertificateMapperCfg;
093    import org.opends.server.admin.std.server.ConnectionHandlerCfg;
094    import org.opends.server.admin.std.server.CryptoManagerCfg;
095    import org.opends.server.admin.std.server.EntryCacheCfg;
096    import org.opends.server.admin.std.server.ExtendedOperationHandlerCfg;
097    import org.opends.server.admin.std.server.GlobalCfg;
098    import org.opends.server.admin.std.server.GroupImplementationCfg;
099    import org.opends.server.admin.std.server.IdentityMapperCfg;
100    import org.opends.server.admin.std.server.KeyManagerProviderCfg;
101    import org.opends.server.admin.std.server.LogPublisherCfg;
102    import org.opends.server.admin.std.server.LogRetentionPolicyCfg;
103    import org.opends.server.admin.std.server.LogRotationPolicyCfg;
104    import org.opends.server.admin.std.server.MatchingRuleCfg;
105    import org.opends.server.admin.std.server.MonitorProviderCfg;
106    import org.opends.server.admin.std.server.NetworkGroupCfg;
107    import org.opends.server.admin.std.server.PasswordGeneratorCfg;
108    import org.opends.server.admin.std.server.PasswordPolicyCfg;
109    import org.opends.server.admin.std.server.PasswordStorageSchemeCfg;
110    import org.opends.server.admin.std.server.PasswordValidatorCfg;
111    import org.opends.server.admin.std.server.PluginRootCfg;
112    import org.opends.server.admin.std.server.RootCfg;
113    import org.opends.server.admin.std.server.RootDNCfg;
114    import org.opends.server.admin.std.server.RootDSEBackendCfg;
115    import org.opends.server.admin.std.server.SASLMechanismHandlerCfg;
116    import org.opends.server.admin.std.server.SynchronizationProviderCfg;
117    import org.opends.server.admin.std.server.TrustManagerProviderCfg;
118    import org.opends.server.admin.std.server.VirtualAttributeCfg;
119    import org.opends.server.admin.std.server.WorkflowCfg;
120    import org.opends.server.admin.std.server.WorkflowElementCfg;
121    import org.opends.server.admin.std.server.WorkQueueCfg;
122    import org.opends.server.admin.Tag;
123    import org.opends.server.admin.TopCfgDefn;
124    import org.opends.server.config.ConfigException;
125    import org.opends.server.types.DN;
126    
127    
128    
129    /**
130     * An interface for querying the Root managed object definition meta
131     * information.
132     * <p>
133     * The root configuration provides an entry point to the rest of the
134     * OpenDS Directory Server configuration.
135     */
136    public final class RootCfgDefn extends ManagedObjectDefinition<RootCfgClient, RootCfg> {
137    
138      // The singleton configuration definition instance.
139      private static final RootCfgDefn INSTANCE = new RootCfgDefn();
140    
141    
142    
143      // Define managed object tags.
144      static {
145        Tag.define("core-server");
146        Tag.define("database");
147        Tag.define("logging");
148        Tag.define("replication");
149        Tag.define("security");
150        Tag.define("user-management");
151      }
152    
153    
154    
155      // The "access-control-handler" relation definition.
156      private static final SingletonRelationDefinition<AccessControlHandlerCfgClient, AccessControlHandlerCfg> RD_ACCESS_CONTROL_HANDLER;
157    
158    
159    
160      // The "account-status-notification-handlers" relation definition.
161      private static final InstantiableRelationDefinition<AccountStatusNotificationHandlerCfgClient, AccountStatusNotificationHandlerCfg> RD_ACCOUNT_STATUS_NOTIFICATION_HANDLERS;
162    
163    
164    
165      // The "alert-handlers" relation definition.
166      private static final InstantiableRelationDefinition<AlertHandlerCfgClient, AlertHandlerCfg> RD_ALERT_HANDLERS;
167    
168    
169    
170      // The "attribute-syntaxes" relation definition.
171      private static final InstantiableRelationDefinition<AttributeSyntaxCfgClient, AttributeSyntaxCfg> RD_ATTRIBUTE_SYNTAXES;
172    
173    
174    
175      // The "backends" relation definition.
176      private static final InstantiableRelationDefinition<BackendCfgClient, BackendCfg> RD_BACKENDS;
177    
178    
179    
180      // The "certificate-mappers" relation definition.
181      private static final InstantiableRelationDefinition<CertificateMapperCfgClient, CertificateMapperCfg> RD_CERTIFICATE_MAPPERS;
182    
183    
184    
185      // The "connection-handlers" relation definition.
186      private static final InstantiableRelationDefinition<ConnectionHandlerCfgClient, ConnectionHandlerCfg> RD_CONNECTION_HANDLERS;
187    
188    
189    
190      // The "crypto-manager" relation definition.
191      private static final SingletonRelationDefinition<CryptoManagerCfgClient, CryptoManagerCfg> RD_CRYPTO_MANAGER;
192    
193    
194    
195      // The "entry-caches" relation definition.
196      private static final InstantiableRelationDefinition<EntryCacheCfgClient, EntryCacheCfg> RD_ENTRY_CACHES;
197    
198    
199    
200      // The "extended-operation-handlers" relation definition.
201      private static final InstantiableRelationDefinition<ExtendedOperationHandlerCfgClient, ExtendedOperationHandlerCfg> RD_EXTENDED_OPERATION_HANDLERS;
202    
203    
204    
205      // The "global-configuration" relation definition.
206      private static final SingletonRelationDefinition<GlobalCfgClient, GlobalCfg> RD_GLOBAL_CONFIGURATION;
207    
208    
209    
210      // The "group-implementations" relation definition.
211      private static final InstantiableRelationDefinition<GroupImplementationCfgClient, GroupImplementationCfg> RD_GROUP_IMPLEMENTATIONS;
212    
213    
214    
215      // The "identity-mappers" relation definition.
216      private static final InstantiableRelationDefinition<IdentityMapperCfgClient, IdentityMapperCfg> RD_IDENTITY_MAPPERS;
217    
218    
219    
220      // The "key-manager-providers" relation definition.
221      private static final InstantiableRelationDefinition<KeyManagerProviderCfgClient, KeyManagerProviderCfg> RD_KEY_MANAGER_PROVIDERS;
222    
223    
224    
225      // The "log-publishers" relation definition.
226      private static final InstantiableRelationDefinition<LogPublisherCfgClient, LogPublisherCfg> RD_LOG_PUBLISHERS;
227    
228    
229    
230      // The "log-retention-policies" relation definition.
231      private static final InstantiableRelationDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> RD_LOG_RETENTION_POLICIES;
232    
233    
234    
235      // The "log-rotation-policies" relation definition.
236      private static final InstantiableRelationDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> RD_LOG_ROTATION_POLICIES;
237    
238    
239    
240      // The "matching-rules" relation definition.
241      private static final InstantiableRelationDefinition<MatchingRuleCfgClient, MatchingRuleCfg> RD_MATCHING_RULES;
242    
243    
244    
245      // The "monitor-providers" relation definition.
246      private static final InstantiableRelationDefinition<MonitorProviderCfgClient, MonitorProviderCfg> RD_MONITOR_PROVIDERS;
247    
248    
249    
250      // The "network-groups" relation definition.
251      private static final InstantiableRelationDefinition<NetworkGroupCfgClient, NetworkGroupCfg> RD_NETWORK_GROUPS;
252    
253    
254    
255      // The "password-generators" relation definition.
256      private static final InstantiableRelationDefinition<PasswordGeneratorCfgClient, PasswordGeneratorCfg> RD_PASSWORD_GENERATORS;
257    
258    
259    
260      // The "password-policies" relation definition.
261      private static final InstantiableRelationDefinition<PasswordPolicyCfgClient, PasswordPolicyCfg> RD_PASSWORD_POLICIES;
262    
263    
264    
265      // The "password-storage-schemes" relation definition.
266      private static final InstantiableRelationDefinition<PasswordStorageSchemeCfgClient, PasswordStorageSchemeCfg> RD_PASSWORD_STORAGE_SCHEMES;
267    
268    
269    
270      // The "password-validators" relation definition.
271      private static final InstantiableRelationDefinition<PasswordValidatorCfgClient, PasswordValidatorCfg> RD_PASSWORD_VALIDATORS;
272    
273    
274    
275      // The "plugin-root" relation definition.
276      private static final SingletonRelationDefinition<PluginRootCfgClient, PluginRootCfg> RD_PLUGIN_ROOT;
277    
278    
279    
280      // The "root-dn" relation definition.
281      private static final SingletonRelationDefinition<RootDNCfgClient, RootDNCfg> RD_ROOT_DN;
282    
283    
284    
285      // The "root-dse-backend" relation definition.
286      private static final SingletonRelationDefinition<RootDSEBackendCfgClient, RootDSEBackendCfg> RD_ROOT_DSE_BACKEND;
287    
288    
289    
290      // The "sasl-mechanism-handlers" relation definition.
291      private static final InstantiableRelationDefinition<SASLMechanismHandlerCfgClient, SASLMechanismHandlerCfg> RD_SASL_MECHANISM_HANDLERS;
292    
293    
294    
295      // The "synchronization-providers" relation definition.
296      private static final InstantiableRelationDefinition<SynchronizationProviderCfgClient, SynchronizationProviderCfg> RD_SYNCHRONIZATION_PROVIDERS;
297    
298    
299    
300      // The "trust-manager-providers" relation definition.
301      private static final InstantiableRelationDefinition<TrustManagerProviderCfgClient, TrustManagerProviderCfg> RD_TRUST_MANAGER_PROVIDERS;
302    
303    
304    
305      // The "virtual-attributes" relation definition.
306      private static final InstantiableRelationDefinition<VirtualAttributeCfgClient, VirtualAttributeCfg> RD_VIRTUAL_ATTRIBUTES;
307    
308    
309    
310      // The "workflows" relation definition.
311      private static final InstantiableRelationDefinition<WorkflowCfgClient, WorkflowCfg> RD_WORKFLOWS;
312    
313    
314    
315      // The "workflow-elements" relation definition.
316      private static final InstantiableRelationDefinition<WorkflowElementCfgClient, WorkflowElementCfg> RD_WORKFLOW_ELEMENTS;
317    
318    
319    
320      // The "work-queue" relation definition.
321      private static final SingletonRelationDefinition<WorkQueueCfgClient, WorkQueueCfg> RD_WORK_QUEUE;
322    
323    
324    
325      // Build the "access-control-handler" relation definition.
326      static {
327        SingletonRelationDefinition.Builder<AccessControlHandlerCfgClient, AccessControlHandlerCfg> builder =
328          new SingletonRelationDefinition.Builder<AccessControlHandlerCfgClient, AccessControlHandlerCfg>(INSTANCE, "access-control-handler", AccessControlHandlerCfgDefn.getInstance());
329        RD_ACCESS_CONTROL_HANDLER = builder.getInstance();
330        INSTANCE.registerRelationDefinition(RD_ACCESS_CONTROL_HANDLER);
331      }
332    
333    
334    
335      // Build the "account-status-notification-handlers" relation definition.
336      static {
337        InstantiableRelationDefinition.Builder<AccountStatusNotificationHandlerCfgClient, AccountStatusNotificationHandlerCfg> builder =
338          new InstantiableRelationDefinition.Builder<AccountStatusNotificationHandlerCfgClient, AccountStatusNotificationHandlerCfg>(INSTANCE, "account-status-notification-handler", "account-status-notification-handlers", AccountStatusNotificationHandlerCfgDefn.getInstance());
339        RD_ACCOUNT_STATUS_NOTIFICATION_HANDLERS = builder.getInstance();
340        INSTANCE.registerRelationDefinition(RD_ACCOUNT_STATUS_NOTIFICATION_HANDLERS);
341      }
342    
343    
344    
345      // Build the "alert-handlers" relation definition.
346      static {
347        InstantiableRelationDefinition.Builder<AlertHandlerCfgClient, AlertHandlerCfg> builder =
348          new InstantiableRelationDefinition.Builder<AlertHandlerCfgClient, AlertHandlerCfg>(INSTANCE, "alert-handler", "alert-handlers", AlertHandlerCfgDefn.getInstance());
349        RD_ALERT_HANDLERS = builder.getInstance();
350        INSTANCE.registerRelationDefinition(RD_ALERT_HANDLERS);
351      }
352    
353    
354    
355      // Build the "attribute-syntaxes" relation definition.
356      static {
357        InstantiableRelationDefinition.Builder<AttributeSyntaxCfgClient, AttributeSyntaxCfg> builder =
358          new InstantiableRelationDefinition.Builder<AttributeSyntaxCfgClient, AttributeSyntaxCfg>(INSTANCE, "attribute-syntax", "attribute-syntaxes", AttributeSyntaxCfgDefn.getInstance());
359        RD_ATTRIBUTE_SYNTAXES = builder.getInstance();
360        INSTANCE.registerRelationDefinition(RD_ATTRIBUTE_SYNTAXES);
361      }
362    
363    
364    
365      // Build the "backends" relation definition.
366      static {
367        InstantiableRelationDefinition.Builder<BackendCfgClient, BackendCfg> builder =
368          new InstantiableRelationDefinition.Builder<BackendCfgClient, BackendCfg>(INSTANCE, "backend", "backends", BackendCfgDefn.getInstance());
369        builder.setNamingProperty(BackendCfgDefn.getInstance().getBackendIdPropertyDefinition());
370        RD_BACKENDS = builder.getInstance();
371        INSTANCE.registerRelationDefinition(RD_BACKENDS);
372      }
373    
374    
375    
376      // Build the "certificate-mappers" relation definition.
377      static {
378        InstantiableRelationDefinition.Builder<CertificateMapperCfgClient, CertificateMapperCfg> builder =
379          new InstantiableRelationDefinition.Builder<CertificateMapperCfgClient, CertificateMapperCfg>(INSTANCE, "certificate-mapper", "certificate-mappers", CertificateMapperCfgDefn.getInstance());
380        RD_CERTIFICATE_MAPPERS = builder.getInstance();
381        INSTANCE.registerRelationDefinition(RD_CERTIFICATE_MAPPERS);
382      }
383    
384    
385    
386      // Build the "connection-handlers" relation definition.
387      static {
388        InstantiableRelationDefinition.Builder<ConnectionHandlerCfgClient, ConnectionHandlerCfg> builder =
389          new InstantiableRelationDefinition.Builder<ConnectionHandlerCfgClient, ConnectionHandlerCfg>(INSTANCE, "connection-handler", "connection-handlers", ConnectionHandlerCfgDefn.getInstance());
390        RD_CONNECTION_HANDLERS = builder.getInstance();
391        INSTANCE.registerRelationDefinition(RD_CONNECTION_HANDLERS);
392      }
393    
394    
395    
396      // Build the "crypto-manager" relation definition.
397      static {
398        SingletonRelationDefinition.Builder<CryptoManagerCfgClient, CryptoManagerCfg> builder =
399          new SingletonRelationDefinition.Builder<CryptoManagerCfgClient, CryptoManagerCfg>(INSTANCE, "crypto-manager", CryptoManagerCfgDefn.getInstance());
400        RD_CRYPTO_MANAGER = builder.getInstance();
401        INSTANCE.registerRelationDefinition(RD_CRYPTO_MANAGER);
402      }
403    
404    
405    
406      // Build the "entry-caches" relation definition.
407      static {
408        InstantiableRelationDefinition.Builder<EntryCacheCfgClient, EntryCacheCfg> builder =
409          new InstantiableRelationDefinition.Builder<EntryCacheCfgClient, EntryCacheCfg>(INSTANCE, "entry-cache", "entry-caches", EntryCacheCfgDefn.getInstance());
410        RD_ENTRY_CACHES = builder.getInstance();
411        INSTANCE.registerRelationDefinition(RD_ENTRY_CACHES);
412      }
413    
414    
415    
416      // Build the "extended-operation-handlers" relation definition.
417      static {
418        InstantiableRelationDefinition.Builder<ExtendedOperationHandlerCfgClient, ExtendedOperationHandlerCfg> builder =
419          new InstantiableRelationDefinition.Builder<ExtendedOperationHandlerCfgClient, ExtendedOperationHandlerCfg>(INSTANCE, "extended-operation-handler", "extended-operation-handlers", ExtendedOperationHandlerCfgDefn.getInstance());
420        RD_EXTENDED_OPERATION_HANDLERS = builder.getInstance();
421        INSTANCE.registerRelationDefinition(RD_EXTENDED_OPERATION_HANDLERS);
422      }
423    
424    
425    
426      // Build the "global-configuration" relation definition.
427      static {
428        SingletonRelationDefinition.Builder<GlobalCfgClient, GlobalCfg> builder =
429          new SingletonRelationDefinition.Builder<GlobalCfgClient, GlobalCfg>(INSTANCE, "global-configuration", GlobalCfgDefn.getInstance());
430        RD_GLOBAL_CONFIGURATION = builder.getInstance();
431        INSTANCE.registerRelationDefinition(RD_GLOBAL_CONFIGURATION);
432      }
433    
434    
435    
436      // Build the "group-implementations" relation definition.
437      static {
438        InstantiableRelationDefinition.Builder<GroupImplementationCfgClient, GroupImplementationCfg> builder =
439          new InstantiableRelationDefinition.Builder<GroupImplementationCfgClient, GroupImplementationCfg>(INSTANCE, "group-implementation", "group-implementations", GroupImplementationCfgDefn.getInstance());
440        RD_GROUP_IMPLEMENTATIONS = builder.getInstance();
441        INSTANCE.registerRelationDefinition(RD_GROUP_IMPLEMENTATIONS);
442      }
443    
444    
445    
446      // Build the "identity-mappers" relation definition.
447      static {
448        InstantiableRelationDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg> builder =
449          new InstantiableRelationDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg>(INSTANCE, "identity-mapper", "identity-mappers", IdentityMapperCfgDefn.getInstance());
450        RD_IDENTITY_MAPPERS = builder.getInstance();
451        INSTANCE.registerRelationDefinition(RD_IDENTITY_MAPPERS);
452      }
453    
454    
455    
456      // Build the "key-manager-providers" relation definition.
457      static {
458        InstantiableRelationDefinition.Builder<KeyManagerProviderCfgClient, KeyManagerProviderCfg> builder =
459          new InstantiableRelationDefinition.Builder<KeyManagerProviderCfgClient, KeyManagerProviderCfg>(INSTANCE, "key-manager-provider", "key-manager-providers", KeyManagerProviderCfgDefn.getInstance());
460        RD_KEY_MANAGER_PROVIDERS = builder.getInstance();
461        INSTANCE.registerRelationDefinition(RD_KEY_MANAGER_PROVIDERS);
462      }
463    
464    
465    
466      // Build the "log-publishers" relation definition.
467      static {
468        InstantiableRelationDefinition.Builder<LogPublisherCfgClient, LogPublisherCfg> builder =
469          new InstantiableRelationDefinition.Builder<LogPublisherCfgClient, LogPublisherCfg>(INSTANCE, "log-publisher", "log-publishers", LogPublisherCfgDefn.getInstance());
470        RD_LOG_PUBLISHERS = builder.getInstance();
471        INSTANCE.registerRelationDefinition(RD_LOG_PUBLISHERS);
472      }
473    
474    
475    
476      // Build the "log-retention-policies" relation definition.
477      static {
478        InstantiableRelationDefinition.Builder<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> builder =
479          new InstantiableRelationDefinition.Builder<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg>(INSTANCE, "log-retention-policy", "log-retention-policies", LogRetentionPolicyCfgDefn.getInstance());
480        RD_LOG_RETENTION_POLICIES = builder.getInstance();
481        INSTANCE.registerRelationDefinition(RD_LOG_RETENTION_POLICIES);
482      }
483    
484    
485    
486      // Build the "log-rotation-policies" relation definition.
487      static {
488        InstantiableRelationDefinition.Builder<LogRotationPolicyCfgClient, LogRotationPolicyCfg> builder =
489          new InstantiableRelationDefinition.Builder<LogRotationPolicyCfgClient, LogRotationPolicyCfg>(INSTANCE, "log-rotation-policy", "log-rotation-policies", LogRotationPolicyCfgDefn.getInstance());
490        RD_LOG_ROTATION_POLICIES = builder.getInstance();
491        INSTANCE.registerRelationDefinition(RD_LOG_ROTATION_POLICIES);
492      }
493    
494    
495    
496      // Build the "matching-rules" relation definition.
497      static {
498        InstantiableRelationDefinition.Builder<MatchingRuleCfgClient, MatchingRuleCfg> builder =
499          new InstantiableRelationDefinition.Builder<MatchingRuleCfgClient, MatchingRuleCfg>(INSTANCE, "matching-rule", "matching-rules", MatchingRuleCfgDefn.getInstance());
500        RD_MATCHING_RULES = builder.getInstance();
501        INSTANCE.registerRelationDefinition(RD_MATCHING_RULES);
502      }
503    
504    
505    
506      // Build the "monitor-providers" relation definition.
507      static {
508        InstantiableRelationDefinition.Builder<MonitorProviderCfgClient, MonitorProviderCfg> builder =
509          new InstantiableRelationDefinition.Builder<MonitorProviderCfgClient, MonitorProviderCfg>(INSTANCE, "monitor-provider", "monitor-providers", MonitorProviderCfgDefn.getInstance());
510        RD_MONITOR_PROVIDERS = builder.getInstance();
511        INSTANCE.registerRelationDefinition(RD_MONITOR_PROVIDERS);
512      }
513    
514    
515    
516      // Build the "network-groups" relation definition.
517      static {
518        InstantiableRelationDefinition.Builder<NetworkGroupCfgClient, NetworkGroupCfg> builder =
519          new InstantiableRelationDefinition.Builder<NetworkGroupCfgClient, NetworkGroupCfg>(INSTANCE, "network-group", "network-groups", NetworkGroupCfgDefn.getInstance());
520        builder.setNamingProperty(NetworkGroupCfgDefn.getInstance().getNetworkGroupIdPropertyDefinition());
521        builder.setOption(RelationOption.HIDDEN);
522        RD_NETWORK_GROUPS = builder.getInstance();
523        INSTANCE.registerRelationDefinition(RD_NETWORK_GROUPS);
524      }
525    
526    
527    
528      // Build the "password-generators" relation definition.
529      static {
530        InstantiableRelationDefinition.Builder<PasswordGeneratorCfgClient, PasswordGeneratorCfg> builder =
531          new InstantiableRelationDefinition.Builder<PasswordGeneratorCfgClient, PasswordGeneratorCfg>(INSTANCE, "password-generator", "password-generators", PasswordGeneratorCfgDefn.getInstance());
532        RD_PASSWORD_GENERATORS = builder.getInstance();
533        INSTANCE.registerRelationDefinition(RD_PASSWORD_GENERATORS);
534      }
535    
536    
537    
538      // Build the "password-policies" relation definition.
539      static {
540        InstantiableRelationDefinition.Builder<PasswordPolicyCfgClient, PasswordPolicyCfg> builder =
541          new InstantiableRelationDefinition.Builder<PasswordPolicyCfgClient, PasswordPolicyCfg>(INSTANCE, "password-policy", "password-policies", PasswordPolicyCfgDefn.getInstance());
542        RD_PASSWORD_POLICIES = builder.getInstance();
543        INSTANCE.registerRelationDefinition(RD_PASSWORD_POLICIES);
544      }
545    
546    
547    
548      // Build the "password-storage-schemes" relation definition.
549      static {
550        InstantiableRelationDefinition.Builder<PasswordStorageSchemeCfgClient, PasswordStorageSchemeCfg> builder =
551          new InstantiableRelationDefinition.Builder<PasswordStorageSchemeCfgClient, PasswordStorageSchemeCfg>(INSTANCE, "password-storage-scheme", "password-storage-schemes", PasswordStorageSchemeCfgDefn.getInstance());
552        RD_PASSWORD_STORAGE_SCHEMES = builder.getInstance();
553        INSTANCE.registerRelationDefinition(RD_PASSWORD_STORAGE_SCHEMES);
554      }
555    
556    
557    
558      // Build the "password-validators" relation definition.
559      static {
560        InstantiableRelationDefinition.Builder<PasswordValidatorCfgClient, PasswordValidatorCfg> builder =
561          new InstantiableRelationDefinition.Builder<PasswordValidatorCfgClient, PasswordValidatorCfg>(INSTANCE, "password-validator", "password-validators", PasswordValidatorCfgDefn.getInstance());
562        RD_PASSWORD_VALIDATORS = builder.getInstance();
563        INSTANCE.registerRelationDefinition(RD_PASSWORD_VALIDATORS);
564      }
565    
566    
567    
568      // Build the "plugin-root" relation definition.
569      static {
570        SingletonRelationDefinition.Builder<PluginRootCfgClient, PluginRootCfg> builder =
571          new SingletonRelationDefinition.Builder<PluginRootCfgClient, PluginRootCfg>(INSTANCE, "plugin-root", PluginRootCfgDefn.getInstance());
572        RD_PLUGIN_ROOT = builder.getInstance();
573        INSTANCE.registerRelationDefinition(RD_PLUGIN_ROOT);
574      }
575    
576    
577    
578      // Build the "root-dn" relation definition.
579      static {
580        SingletonRelationDefinition.Builder<RootDNCfgClient, RootDNCfg> builder =
581          new SingletonRelationDefinition.Builder<RootDNCfgClient, RootDNCfg>(INSTANCE, "root-dn", RootDNCfgDefn.getInstance());
582        RD_ROOT_DN = builder.getInstance();
583        INSTANCE.registerRelationDefinition(RD_ROOT_DN);
584      }
585    
586    
587    
588      // Build the "root-dse-backend" relation definition.
589      static {
590        SingletonRelationDefinition.Builder<RootDSEBackendCfgClient, RootDSEBackendCfg> builder =
591          new SingletonRelationDefinition.Builder<RootDSEBackendCfgClient, RootDSEBackendCfg>(INSTANCE, "root-dse-backend", RootDSEBackendCfgDefn.getInstance());
592        RD_ROOT_DSE_BACKEND = builder.getInstance();
593        INSTANCE.registerRelationDefinition(RD_ROOT_DSE_BACKEND);
594      }
595    
596    
597    
598      // Build the "sasl-mechanism-handlers" relation definition.
599      static {
600        InstantiableRelationDefinition.Builder<SASLMechanismHandlerCfgClient, SASLMechanismHandlerCfg> builder =
601          new InstantiableRelationDefinition.Builder<SASLMechanismHandlerCfgClient, SASLMechanismHandlerCfg>(INSTANCE, "sasl-mechanism-handler", "sasl-mechanism-handlers", SASLMechanismHandlerCfgDefn.getInstance());
602        RD_SASL_MECHANISM_HANDLERS = builder.getInstance();
603        INSTANCE.registerRelationDefinition(RD_SASL_MECHANISM_HANDLERS);
604      }
605    
606    
607    
608      // Build the "synchronization-providers" relation definition.
609      static {
610        InstantiableRelationDefinition.Builder<SynchronizationProviderCfgClient, SynchronizationProviderCfg> builder =
611          new InstantiableRelationDefinition.Builder<SynchronizationProviderCfgClient, SynchronizationProviderCfg>(INSTANCE, "synchronization-provider", "synchronization-providers", SynchronizationProviderCfgDefn.getInstance());
612        RD_SYNCHRONIZATION_PROVIDERS = builder.getInstance();
613        INSTANCE.registerRelationDefinition(RD_SYNCHRONIZATION_PROVIDERS);
614      }
615    
616    
617    
618      // Build the "trust-manager-providers" relation definition.
619      static {
620        InstantiableRelationDefinition.Builder<TrustManagerProviderCfgClient, TrustManagerProviderCfg> builder =
621          new InstantiableRelationDefinition.Builder<TrustManagerProviderCfgClient, TrustManagerProviderCfg>(INSTANCE, "trust-manager-provider", "trust-manager-providers", TrustManagerProviderCfgDefn.getInstance());
622        RD_TRUST_MANAGER_PROVIDERS = builder.getInstance();
623        INSTANCE.registerRelationDefinition(RD_TRUST_MANAGER_PROVIDERS);
624      }
625    
626    
627    
628      // Build the "virtual-attributes" relation definition.
629      static {
630        InstantiableRelationDefinition.Builder<VirtualAttributeCfgClient, VirtualAttributeCfg> builder =
631          new InstantiableRelationDefinition.Builder<VirtualAttributeCfgClient, VirtualAttributeCfg>(INSTANCE, "virtual-attribute", "virtual-attributes", VirtualAttributeCfgDefn.getInstance());
632        RD_VIRTUAL_ATTRIBUTES = builder.getInstance();
633        INSTANCE.registerRelationDefinition(RD_VIRTUAL_ATTRIBUTES);
634      }
635    
636    
637    
638      // Build the "workflows" relation definition.
639      static {
640        InstantiableRelationDefinition.Builder<WorkflowCfgClient, WorkflowCfg> builder =
641          new InstantiableRelationDefinition.Builder<WorkflowCfgClient, WorkflowCfg>(INSTANCE, "workflow", "workflows", WorkflowCfgDefn.getInstance());
642        builder.setNamingProperty(WorkflowCfgDefn.getInstance().getWorkflowIdPropertyDefinition());
643        builder.setOption(RelationOption.HIDDEN);
644        RD_WORKFLOWS = builder.getInstance();
645        INSTANCE.registerRelationDefinition(RD_WORKFLOWS);
646      }
647    
648    
649    
650      // Build the "workflow-elements" relation definition.
651      static {
652        InstantiableRelationDefinition.Builder<WorkflowElementCfgClient, WorkflowElementCfg> builder =
653          new InstantiableRelationDefinition.Builder<WorkflowElementCfgClient, WorkflowElementCfg>(INSTANCE, "workflow-element", "workflow-elements", WorkflowElementCfgDefn.getInstance());
654        builder.setNamingProperty(WorkflowElementCfgDefn.getInstance().getWorkflowElementIdPropertyDefinition());
655        builder.setOption(RelationOption.HIDDEN);
656        RD_WORKFLOW_ELEMENTS = builder.getInstance();
657        INSTANCE.registerRelationDefinition(RD_WORKFLOW_ELEMENTS);
658      }
659    
660    
661    
662      // Build the "work-queue" relation definition.
663      static {
664        SingletonRelationDefinition.Builder<WorkQueueCfgClient, WorkQueueCfg> builder =
665          new SingletonRelationDefinition.Builder<WorkQueueCfgClient, WorkQueueCfg>(INSTANCE, "work-queue", WorkQueueCfgDefn.getInstance());
666        RD_WORK_QUEUE = builder.getInstance();
667        INSTANCE.registerRelationDefinition(RD_WORK_QUEUE);
668      }
669    
670    
671    
672      /**
673       * Get the Root configuration definition singleton.
674       *
675       * @return Returns the Root configuration definition singleton.
676       */
677      public static RootCfgDefn getInstance() {
678        return INSTANCE;
679      }
680    
681    
682    
683      /**
684       * Private constructor.
685       */
686      private RootCfgDefn() {
687        super("", TopCfgDefn.getInstance());
688      }
689    
690    
691    
692      /**
693       * {@inheritDoc}
694       */
695      public RootCfgClient createClientConfiguration(
696          ManagedObject<? extends RootCfgClient> impl) {
697        return new RootCfgClientImpl(impl);
698      }
699    
700    
701    
702      /**
703       * {@inheritDoc}
704       */
705      public RootCfg createServerConfiguration(
706          ServerManagedObject<? extends RootCfg> impl) {
707        return new RootCfgServerImpl(impl);
708      }
709    
710    
711    
712      /**
713       * {@inheritDoc}
714       */
715      public Class<RootCfg> getServerConfigurationClass() {
716        return RootCfg.class;
717      }
718    
719    
720    
721      /**
722       * Get the "access-control-handler" relation definition.
723       *
724       * @return Returns the "access-control-handler" relation definition.
725       */
726      public SingletonRelationDefinition<AccessControlHandlerCfgClient,AccessControlHandlerCfg> getAccessControlHandlerRelationDefinition() {
727        return RD_ACCESS_CONTROL_HANDLER;
728      }
729    
730    
731    
732      /**
733       * Get the "account-status-notification-handlers" relation definition.
734       *
735       * @return Returns the "account-status-notification-handlers" relation definition.
736       */
737      public InstantiableRelationDefinition<AccountStatusNotificationHandlerCfgClient,AccountStatusNotificationHandlerCfg> getAccountStatusNotificationHandlersRelationDefinition() {
738        return RD_ACCOUNT_STATUS_NOTIFICATION_HANDLERS;
739      }
740    
741    
742    
743      /**
744       * Get the "alert-handlers" relation definition.
745       *
746       * @return Returns the "alert-handlers" relation definition.
747       */
748      public InstantiableRelationDefinition<AlertHandlerCfgClient,AlertHandlerCfg> getAlertHandlersRelationDefinition() {
749        return RD_ALERT_HANDLERS;
750      }
751    
752    
753    
754      /**
755       * Get the "attribute-syntaxes" relation definition.
756       *
757       * @return Returns the "attribute-syntaxes" relation definition.
758       */
759      public InstantiableRelationDefinition<AttributeSyntaxCfgClient,AttributeSyntaxCfg> getAttributeSyntaxesRelationDefinition() {
760        return RD_ATTRIBUTE_SYNTAXES;
761      }
762    
763    
764    
765      /**
766       * Get the "backends" relation definition.
767       *
768       * @return Returns the "backends" relation definition.
769       */
770      public InstantiableRelationDefinition<BackendCfgClient,BackendCfg> getBackendsRelationDefinition() {
771        return RD_BACKENDS;
772      }
773    
774    
775    
776      /**
777       * Get the "certificate-mappers" relation definition.
778       *
779       * @return Returns the "certificate-mappers" relation definition.
780       */
781      public InstantiableRelationDefinition<CertificateMapperCfgClient,CertificateMapperCfg> getCertificateMappersRelationDefinition() {
782        return RD_CERTIFICATE_MAPPERS;
783      }
784    
785    
786    
787      /**
788       * Get the "connection-handlers" relation definition.
789       *
790       * @return Returns the "connection-handlers" relation definition.
791       */
792      public InstantiableRelationDefinition<ConnectionHandlerCfgClient,ConnectionHandlerCfg> getConnectionHandlersRelationDefinition() {
793        return RD_CONNECTION_HANDLERS;
794      }
795    
796    
797    
798      /**
799       * Get the "crypto-manager" relation definition.
800       *
801       * @return Returns the "crypto-manager" relation definition.
802       */
803      public SingletonRelationDefinition<CryptoManagerCfgClient,CryptoManagerCfg> getCryptoManagerRelationDefinition() {
804        return RD_CRYPTO_MANAGER;
805      }
806    
807    
808    
809      /**
810       * Get the "entry-caches" relation definition.
811       *
812       * @return Returns the "entry-caches" relation definition.
813       */
814      public InstantiableRelationDefinition<EntryCacheCfgClient,EntryCacheCfg> getEntryCachesRelationDefinition() {
815        return RD_ENTRY_CACHES;
816      }
817    
818    
819    
820      /**
821       * Get the "extended-operation-handlers" relation definition.
822       *
823       * @return Returns the "extended-operation-handlers" relation definition.
824       */
825      public InstantiableRelationDefinition<ExtendedOperationHandlerCfgClient,ExtendedOperationHandlerCfg> getExtendedOperationHandlersRelationDefinition() {
826        return RD_EXTENDED_OPERATION_HANDLERS;
827      }
828    
829    
830    
831      /**
832       * Get the "global-configuration" relation definition.
833       *
834       * @return Returns the "global-configuration" relation definition.
835       */
836      public SingletonRelationDefinition<GlobalCfgClient,GlobalCfg> getGlobalConfigurationRelationDefinition() {
837        return RD_GLOBAL_CONFIGURATION;
838      }
839    
840    
841    
842      /**
843       * Get the "group-implementations" relation definition.
844       *
845       * @return Returns the "group-implementations" relation definition.
846       */
847      public InstantiableRelationDefinition<GroupImplementationCfgClient,GroupImplementationCfg> getGroupImplementationsRelationDefinition() {
848        return RD_GROUP_IMPLEMENTATIONS;
849      }
850    
851    
852    
853      /**
854       * Get the "identity-mappers" relation definition.
855       *
856       * @return Returns the "identity-mappers" relation definition.
857       */
858      public InstantiableRelationDefinition<IdentityMapperCfgClient,IdentityMapperCfg> getIdentityMappersRelationDefinition() {
859        return RD_IDENTITY_MAPPERS;
860      }
861    
862    
863    
864      /**
865       * Get the "key-manager-providers" relation definition.
866       *
867       * @return Returns the "key-manager-providers" relation definition.
868       */
869      public InstantiableRelationDefinition<KeyManagerProviderCfgClient,KeyManagerProviderCfg> getKeyManagerProvidersRelationDefinition() {
870        return RD_KEY_MANAGER_PROVIDERS;
871      }
872    
873    
874    
875      /**
876       * Get the "log-publishers" relation definition.
877       *
878       * @return Returns the "log-publishers" relation definition.
879       */
880      public InstantiableRelationDefinition<LogPublisherCfgClient,LogPublisherCfg> getLogPublishersRelationDefinition() {
881        return RD_LOG_PUBLISHERS;
882      }
883    
884    
885    
886      /**
887       * Get the "log-retention-policies" relation definition.
888       *
889       * @return Returns the "log-retention-policies" relation definition.
890       */
891      public InstantiableRelationDefinition<LogRetentionPolicyCfgClient,LogRetentionPolicyCfg> getLogRetentionPoliciesRelationDefinition() {
892        return RD_LOG_RETENTION_POLICIES;
893      }
894    
895    
896    
897      /**
898       * Get the "log-rotation-policies" relation definition.
899       *
900       * @return Returns the "log-rotation-policies" relation definition.
901       */
902      public InstantiableRelationDefinition<LogRotationPolicyCfgClient,LogRotationPolicyCfg> getLogRotationPoliciesRelationDefinition() {
903        return RD_LOG_ROTATION_POLICIES;
904      }
905    
906    
907    
908      /**
909       * Get the "matching-rules" relation definition.
910       *
911       * @return Returns the "matching-rules" relation definition.
912       */
913      public InstantiableRelationDefinition<MatchingRuleCfgClient,MatchingRuleCfg> getMatchingRulesRelationDefinition() {
914        return RD_MATCHING_RULES;
915      }
916    
917    
918    
919      /**
920       * Get the "monitor-providers" relation definition.
921       *
922       * @return Returns the "monitor-providers" relation definition.
923       */
924      public InstantiableRelationDefinition<MonitorProviderCfgClient,MonitorProviderCfg> getMonitorProvidersRelationDefinition() {
925        return RD_MONITOR_PROVIDERS;
926      }
927    
928    
929    
930      /**
931       * Get the "network-groups" relation definition.
932       *
933       * @return Returns the "network-groups" relation definition.
934       */
935      public InstantiableRelationDefinition<NetworkGroupCfgClient,NetworkGroupCfg> getNetworkGroupsRelationDefinition() {
936        return RD_NETWORK_GROUPS;
937      }
938    
939    
940    
941      /**
942       * Get the "password-generators" relation definition.
943       *
944       * @return Returns the "password-generators" relation definition.
945       */
946      public InstantiableRelationDefinition<PasswordGeneratorCfgClient,PasswordGeneratorCfg> getPasswordGeneratorsRelationDefinition() {
947        return RD_PASSWORD_GENERATORS;
948      }
949    
950    
951    
952      /**
953       * Get the "password-policies" relation definition.
954       *
955       * @return Returns the "password-policies" relation definition.
956       */
957      public InstantiableRelationDefinition<PasswordPolicyCfgClient,PasswordPolicyCfg> getPasswordPoliciesRelationDefinition() {
958        return RD_PASSWORD_POLICIES;
959      }
960    
961    
962    
963      /**
964       * Get the "password-storage-schemes" relation definition.
965       *
966       * @return Returns the "password-storage-schemes" relation definition.
967       */
968      public InstantiableRelationDefinition<PasswordStorageSchemeCfgClient,PasswordStorageSchemeCfg> getPasswordStorageSchemesRelationDefinition() {
969        return RD_PASSWORD_STORAGE_SCHEMES;
970      }
971    
972    
973    
974      /**
975       * Get the "password-validators" relation definition.
976       *
977       * @return Returns the "password-validators" relation definition.
978       */
979      public InstantiableRelationDefinition<PasswordValidatorCfgClient,PasswordValidatorCfg> getPasswordValidatorsRelationDefinition() {
980        return RD_PASSWORD_VALIDATORS;
981      }
982    
983    
984    
985      /**
986       * Get the "plugin-root" relation definition.
987       *
988       * @return Returns the "plugin-root" relation definition.
989       */
990      public SingletonRelationDefinition<PluginRootCfgClient,PluginRootCfg> getPluginRootRelationDefinition() {
991        return RD_PLUGIN_ROOT;
992      }
993    
994    
995    
996      /**
997       * Get the "root-dn" relation definition.
998       *
999       * @return Returns the "root-dn" relation definition.
1000       */
1001      public SingletonRelationDefinition<RootDNCfgClient,RootDNCfg> getRootDNRelationDefinition() {
1002        return RD_ROOT_DN;
1003      }
1004    
1005    
1006    
1007      /**
1008       * Get the "root-dse-backend" relation definition.
1009       *
1010       * @return Returns the "root-dse-backend" relation definition.
1011       */
1012      public SingletonRelationDefinition<RootDSEBackendCfgClient,RootDSEBackendCfg> getRootDSEBackendRelationDefinition() {
1013        return RD_ROOT_DSE_BACKEND;
1014      }
1015    
1016    
1017    
1018      /**
1019       * Get the "sasl-mechanism-handlers" relation definition.
1020       *
1021       * @return Returns the "sasl-mechanism-handlers" relation definition.
1022       */
1023      public InstantiableRelationDefinition<SASLMechanismHandlerCfgClient,SASLMechanismHandlerCfg> getSASLMechanismHandlersRelationDefinition() {
1024        return RD_SASL_MECHANISM_HANDLERS;
1025      }
1026    
1027    
1028    
1029      /**
1030       * Get the "synchronization-providers" relation definition.
1031       *
1032       * @return Returns the "synchronization-providers" relation definition.
1033       */
1034      public InstantiableRelationDefinition<SynchronizationProviderCfgClient,SynchronizationProviderCfg> getSynchronizationProvidersRelationDefinition() {
1035        return RD_SYNCHRONIZATION_PROVIDERS;
1036      }
1037    
1038    
1039    
1040      /**
1041       * Get the "trust-manager-providers" relation definition.
1042       *
1043       * @return Returns the "trust-manager-providers" relation definition.
1044       */
1045      public InstantiableRelationDefinition<TrustManagerProviderCfgClient,TrustManagerProviderCfg> getTrustManagerProvidersRelationDefinition() {
1046        return RD_TRUST_MANAGER_PROVIDERS;
1047      }
1048    
1049    
1050    
1051      /**
1052       * Get the "virtual-attributes" relation definition.
1053       *
1054       * @return Returns the "virtual-attributes" relation definition.
1055       */
1056      public InstantiableRelationDefinition<VirtualAttributeCfgClient,VirtualAttributeCfg> getVirtualAttributesRelationDefinition() {
1057        return RD_VIRTUAL_ATTRIBUTES;
1058      }
1059    
1060    
1061    
1062      /**
1063       * Get the "workflows" relation definition.
1064       *
1065       * @return Returns the "workflows" relation definition.
1066       */
1067      public InstantiableRelationDefinition<WorkflowCfgClient,WorkflowCfg> getWorkflowsRelationDefinition() {
1068        return RD_WORKFLOWS;
1069      }
1070    
1071    
1072    
1073      /**
1074       * Get the "workflow-elements" relation definition.
1075       *
1076       * @return Returns the "workflow-elements" relation definition.
1077       */
1078      public InstantiableRelationDefinition<WorkflowElementCfgClient,WorkflowElementCfg> getWorkflowElementsRelationDefinition() {
1079        return RD_WORKFLOW_ELEMENTS;
1080      }
1081    
1082    
1083    
1084      /**
1085       * Get the "work-queue" relation definition.
1086       *
1087       * @return Returns the "work-queue" relation definition.
1088       */
1089      public SingletonRelationDefinition<WorkQueueCfgClient,WorkQueueCfg> getWorkQueueRelationDefinition() {
1090        return RD_WORK_QUEUE;
1091      }
1092    
1093    
1094    
1095      /**
1096       * Managed object client implementation.
1097       */
1098      private static class RootCfgClientImpl implements
1099        RootCfgClient {
1100    
1101        // Private implementation.
1102        private ManagedObject<? extends RootCfgClient> impl;
1103    
1104    
1105    
1106        // Private constructor.
1107        private RootCfgClientImpl(
1108            ManagedObject<? extends RootCfgClient> impl) {
1109          this.impl = impl;
1110        }
1111    
1112    
1113    
1114        /**
1115         * {@inheritDoc}
1116         */
1117        public AccessControlHandlerCfgClient getAccessControlHandler()
1118            throws DefinitionDecodingException, ManagedObjectDecodingException,
1119            ManagedObjectNotFoundException, ConcurrentModificationException,
1120            AuthorizationException, CommunicationException {
1121          return impl.getChild(INSTANCE.getAccessControlHandlerRelationDefinition()).getConfiguration();
1122        }
1123    
1124    
1125    
1126        /**
1127         * {@inheritDoc}
1128         */
1129        public String[] listAccountStatusNotificationHandlers() throws ConcurrentModificationException,
1130            AuthorizationException, CommunicationException {
1131          return impl.listChildren(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition());
1132        }
1133    
1134    
1135    
1136        /**
1137         * {@inheritDoc}
1138         */
1139        public AccountStatusNotificationHandlerCfgClient getAccountStatusNotificationHandler(String name)
1140            throws DefinitionDecodingException, ManagedObjectDecodingException,
1141            ManagedObjectNotFoundException, ConcurrentModificationException,
1142            AuthorizationException, CommunicationException {
1143          return impl.getChild(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), name).getConfiguration();
1144        }
1145    
1146    
1147    
1148        /**
1149         * {@inheritDoc}
1150         */
1151        public <M extends AccountStatusNotificationHandlerCfgClient> M createAccountStatusNotificationHandler(
1152            ManagedObjectDefinition<M, ? extends AccountStatusNotificationHandlerCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1153          return impl.createChild(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), d, name, exceptions).getConfiguration();
1154        }
1155    
1156    
1157    
1158        /**
1159         * {@inheritDoc}
1160         */
1161        public void removeAccountStatusNotificationHandler(String name)
1162            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1163            OperationRejectedException, AuthorizationException, CommunicationException {
1164          impl.removeChild(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), name);
1165        }
1166    
1167    
1168    
1169        /**
1170         * {@inheritDoc}
1171         */
1172        public String[] listAlertHandlers() throws ConcurrentModificationException,
1173            AuthorizationException, CommunicationException {
1174          return impl.listChildren(INSTANCE.getAlertHandlersRelationDefinition());
1175        }
1176    
1177    
1178    
1179        /**
1180         * {@inheritDoc}
1181         */
1182        public AlertHandlerCfgClient getAlertHandler(String name)
1183            throws DefinitionDecodingException, ManagedObjectDecodingException,
1184            ManagedObjectNotFoundException, ConcurrentModificationException,
1185            AuthorizationException, CommunicationException {
1186          return impl.getChild(INSTANCE.getAlertHandlersRelationDefinition(), name).getConfiguration();
1187        }
1188    
1189    
1190    
1191        /**
1192         * {@inheritDoc}
1193         */
1194        public <M extends AlertHandlerCfgClient> M createAlertHandler(
1195            ManagedObjectDefinition<M, ? extends AlertHandlerCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1196          return impl.createChild(INSTANCE.getAlertHandlersRelationDefinition(), d, name, exceptions).getConfiguration();
1197        }
1198    
1199    
1200    
1201        /**
1202         * {@inheritDoc}
1203         */
1204        public void removeAlertHandler(String name)
1205            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1206            OperationRejectedException, AuthorizationException, CommunicationException {
1207          impl.removeChild(INSTANCE.getAlertHandlersRelationDefinition(), name);
1208        }
1209    
1210    
1211    
1212        /**
1213         * {@inheritDoc}
1214         */
1215        public String[] listAttributeSyntaxes() throws ConcurrentModificationException,
1216            AuthorizationException, CommunicationException {
1217          return impl.listChildren(INSTANCE.getAttributeSyntaxesRelationDefinition());
1218        }
1219    
1220    
1221    
1222        /**
1223         * {@inheritDoc}
1224         */
1225        public AttributeSyntaxCfgClient getAttributeSyntax(String name)
1226            throws DefinitionDecodingException, ManagedObjectDecodingException,
1227            ManagedObjectNotFoundException, ConcurrentModificationException,
1228            AuthorizationException, CommunicationException {
1229          return impl.getChild(INSTANCE.getAttributeSyntaxesRelationDefinition(), name).getConfiguration();
1230        }
1231    
1232    
1233    
1234        /**
1235         * {@inheritDoc}
1236         */
1237        public <M extends AttributeSyntaxCfgClient> M createAttributeSyntax(
1238            ManagedObjectDefinition<M, ? extends AttributeSyntaxCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1239          return impl.createChild(INSTANCE.getAttributeSyntaxesRelationDefinition(), d, name, exceptions).getConfiguration();
1240        }
1241    
1242    
1243    
1244        /**
1245         * {@inheritDoc}
1246         */
1247        public void removeAttributeSyntax(String name)
1248            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1249            OperationRejectedException, AuthorizationException, CommunicationException {
1250          impl.removeChild(INSTANCE.getAttributeSyntaxesRelationDefinition(), name);
1251        }
1252    
1253    
1254    
1255        /**
1256         * {@inheritDoc}
1257         */
1258        public String[] listBackends() throws ConcurrentModificationException,
1259            AuthorizationException, CommunicationException {
1260          return impl.listChildren(INSTANCE.getBackendsRelationDefinition());
1261        }
1262    
1263    
1264    
1265        /**
1266         * {@inheritDoc}
1267         */
1268        public BackendCfgClient getBackend(String name)
1269            throws DefinitionDecodingException, ManagedObjectDecodingException,
1270            ManagedObjectNotFoundException, ConcurrentModificationException,
1271            AuthorizationException, CommunicationException {
1272          return impl.getChild(INSTANCE.getBackendsRelationDefinition(), name).getConfiguration();
1273        }
1274    
1275    
1276    
1277        /**
1278         * {@inheritDoc}
1279         */
1280        public <M extends BackendCfgClient> M createBackend(
1281            ManagedObjectDefinition<M, ? extends BackendCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1282          return impl.createChild(INSTANCE.getBackendsRelationDefinition(), d, name, exceptions).getConfiguration();
1283        }
1284    
1285    
1286    
1287        /**
1288         * {@inheritDoc}
1289         */
1290        public void removeBackend(String name)
1291            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1292            OperationRejectedException, AuthorizationException, CommunicationException {
1293          impl.removeChild(INSTANCE.getBackendsRelationDefinition(), name);
1294        }
1295    
1296    
1297    
1298        /**
1299         * {@inheritDoc}
1300         */
1301        public String[] listCertificateMappers() throws ConcurrentModificationException,
1302            AuthorizationException, CommunicationException {
1303          return impl.listChildren(INSTANCE.getCertificateMappersRelationDefinition());
1304        }
1305    
1306    
1307    
1308        /**
1309         * {@inheritDoc}
1310         */
1311        public CertificateMapperCfgClient getCertificateMapper(String name)
1312            throws DefinitionDecodingException, ManagedObjectDecodingException,
1313            ManagedObjectNotFoundException, ConcurrentModificationException,
1314            AuthorizationException, CommunicationException {
1315          return impl.getChild(INSTANCE.getCertificateMappersRelationDefinition(), name).getConfiguration();
1316        }
1317    
1318    
1319    
1320        /**
1321         * {@inheritDoc}
1322         */
1323        public <M extends CertificateMapperCfgClient> M createCertificateMapper(
1324            ManagedObjectDefinition<M, ? extends CertificateMapperCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1325          return impl.createChild(INSTANCE.getCertificateMappersRelationDefinition(), d, name, exceptions).getConfiguration();
1326        }
1327    
1328    
1329    
1330        /**
1331         * {@inheritDoc}
1332         */
1333        public void removeCertificateMapper(String name)
1334            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1335            OperationRejectedException, AuthorizationException, CommunicationException {
1336          impl.removeChild(INSTANCE.getCertificateMappersRelationDefinition(), name);
1337        }
1338    
1339    
1340    
1341        /**
1342         * {@inheritDoc}
1343         */
1344        public String[] listConnectionHandlers() throws ConcurrentModificationException,
1345            AuthorizationException, CommunicationException {
1346          return impl.listChildren(INSTANCE.getConnectionHandlersRelationDefinition());
1347        }
1348    
1349    
1350    
1351        /**
1352         * {@inheritDoc}
1353         */
1354        public ConnectionHandlerCfgClient getConnectionHandler(String name)
1355            throws DefinitionDecodingException, ManagedObjectDecodingException,
1356            ManagedObjectNotFoundException, ConcurrentModificationException,
1357            AuthorizationException, CommunicationException {
1358          return impl.getChild(INSTANCE.getConnectionHandlersRelationDefinition(), name).getConfiguration();
1359        }
1360    
1361    
1362    
1363        /**
1364         * {@inheritDoc}
1365         */
1366        public <M extends ConnectionHandlerCfgClient> M createConnectionHandler(
1367            ManagedObjectDefinition<M, ? extends ConnectionHandlerCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1368          return impl.createChild(INSTANCE.getConnectionHandlersRelationDefinition(), d, name, exceptions).getConfiguration();
1369        }
1370    
1371    
1372    
1373        /**
1374         * {@inheritDoc}
1375         */
1376        public void removeConnectionHandler(String name)
1377            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1378            OperationRejectedException, AuthorizationException, CommunicationException {
1379          impl.removeChild(INSTANCE.getConnectionHandlersRelationDefinition(), name);
1380        }
1381    
1382    
1383    
1384        /**
1385         * {@inheritDoc}
1386         */
1387        public CryptoManagerCfgClient getCryptoManager()
1388            throws DefinitionDecodingException, ManagedObjectDecodingException,
1389            ManagedObjectNotFoundException, ConcurrentModificationException,
1390            AuthorizationException, CommunicationException {
1391          return impl.getChild(INSTANCE.getCryptoManagerRelationDefinition()).getConfiguration();
1392        }
1393    
1394    
1395    
1396        /**
1397         * {@inheritDoc}
1398         */
1399        public String[] listEntryCaches() throws ConcurrentModificationException,
1400            AuthorizationException, CommunicationException {
1401          return impl.listChildren(INSTANCE.getEntryCachesRelationDefinition());
1402        }
1403    
1404    
1405    
1406        /**
1407         * {@inheritDoc}
1408         */
1409        public EntryCacheCfgClient getEntryCache(String name)
1410            throws DefinitionDecodingException, ManagedObjectDecodingException,
1411            ManagedObjectNotFoundException, ConcurrentModificationException,
1412            AuthorizationException, CommunicationException {
1413          return impl.getChild(INSTANCE.getEntryCachesRelationDefinition(), name).getConfiguration();
1414        }
1415    
1416    
1417    
1418        /**
1419         * {@inheritDoc}
1420         */
1421        public <M extends EntryCacheCfgClient> M createEntryCache(
1422            ManagedObjectDefinition<M, ? extends EntryCacheCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1423          return impl.createChild(INSTANCE.getEntryCachesRelationDefinition(), d, name, exceptions).getConfiguration();
1424        }
1425    
1426    
1427    
1428        /**
1429         * {@inheritDoc}
1430         */
1431        public void removeEntryCache(String name)
1432            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1433            OperationRejectedException, AuthorizationException, CommunicationException {
1434          impl.removeChild(INSTANCE.getEntryCachesRelationDefinition(), name);
1435        }
1436    
1437    
1438    
1439        /**
1440         * {@inheritDoc}
1441         */
1442        public String[] listExtendedOperationHandlers() throws ConcurrentModificationException,
1443            AuthorizationException, CommunicationException {
1444          return impl.listChildren(INSTANCE.getExtendedOperationHandlersRelationDefinition());
1445        }
1446    
1447    
1448    
1449        /**
1450         * {@inheritDoc}
1451         */
1452        public ExtendedOperationHandlerCfgClient getExtendedOperationHandler(String name)
1453            throws DefinitionDecodingException, ManagedObjectDecodingException,
1454            ManagedObjectNotFoundException, ConcurrentModificationException,
1455            AuthorizationException, CommunicationException {
1456          return impl.getChild(INSTANCE.getExtendedOperationHandlersRelationDefinition(), name).getConfiguration();
1457        }
1458    
1459    
1460    
1461        /**
1462         * {@inheritDoc}
1463         */
1464        public <M extends ExtendedOperationHandlerCfgClient> M createExtendedOperationHandler(
1465            ManagedObjectDefinition<M, ? extends ExtendedOperationHandlerCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1466          return impl.createChild(INSTANCE.getExtendedOperationHandlersRelationDefinition(), d, name, exceptions).getConfiguration();
1467        }
1468    
1469    
1470    
1471        /**
1472         * {@inheritDoc}
1473         */
1474        public void removeExtendedOperationHandler(String name)
1475            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1476            OperationRejectedException, AuthorizationException, CommunicationException {
1477          impl.removeChild(INSTANCE.getExtendedOperationHandlersRelationDefinition(), name);
1478        }
1479    
1480    
1481    
1482        /**
1483         * {@inheritDoc}
1484         */
1485        public GlobalCfgClient getGlobalConfiguration()
1486            throws DefinitionDecodingException, ManagedObjectDecodingException,
1487            ManagedObjectNotFoundException, ConcurrentModificationException,
1488            AuthorizationException, CommunicationException {
1489          return impl.getChild(INSTANCE.getGlobalConfigurationRelationDefinition()).getConfiguration();
1490        }
1491    
1492    
1493    
1494        /**
1495         * {@inheritDoc}
1496         */
1497        public String[] listGroupImplementations() throws ConcurrentModificationException,
1498            AuthorizationException, CommunicationException {
1499          return impl.listChildren(INSTANCE.getGroupImplementationsRelationDefinition());
1500        }
1501    
1502    
1503    
1504        /**
1505         * {@inheritDoc}
1506         */
1507        public GroupImplementationCfgClient getGroupImplementation(String name)
1508            throws DefinitionDecodingException, ManagedObjectDecodingException,
1509            ManagedObjectNotFoundException, ConcurrentModificationException,
1510            AuthorizationException, CommunicationException {
1511          return impl.getChild(INSTANCE.getGroupImplementationsRelationDefinition(), name).getConfiguration();
1512        }
1513    
1514    
1515    
1516        /**
1517         * {@inheritDoc}
1518         */
1519        public <M extends GroupImplementationCfgClient> M createGroupImplementation(
1520            ManagedObjectDefinition<M, ? extends GroupImplementationCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1521          return impl.createChild(INSTANCE.getGroupImplementationsRelationDefinition(), d, name, exceptions).getConfiguration();
1522        }
1523    
1524    
1525    
1526        /**
1527         * {@inheritDoc}
1528         */
1529        public void removeGroupImplementation(String name)
1530            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1531            OperationRejectedException, AuthorizationException, CommunicationException {
1532          impl.removeChild(INSTANCE.getGroupImplementationsRelationDefinition(), name);
1533        }
1534    
1535    
1536    
1537        /**
1538         * {@inheritDoc}
1539         */
1540        public String[] listIdentityMappers() throws ConcurrentModificationException,
1541            AuthorizationException, CommunicationException {
1542          return impl.listChildren(INSTANCE.getIdentityMappersRelationDefinition());
1543        }
1544    
1545    
1546    
1547        /**
1548         * {@inheritDoc}
1549         */
1550        public IdentityMapperCfgClient getIdentityMapper(String name)
1551            throws DefinitionDecodingException, ManagedObjectDecodingException,
1552            ManagedObjectNotFoundException, ConcurrentModificationException,
1553            AuthorizationException, CommunicationException {
1554          return impl.getChild(INSTANCE.getIdentityMappersRelationDefinition(), name).getConfiguration();
1555        }
1556    
1557    
1558    
1559        /**
1560         * {@inheritDoc}
1561         */
1562        public <M extends IdentityMapperCfgClient> M createIdentityMapper(
1563            ManagedObjectDefinition<M, ? extends IdentityMapperCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1564          return impl.createChild(INSTANCE.getIdentityMappersRelationDefinition(), d, name, exceptions).getConfiguration();
1565        }
1566    
1567    
1568    
1569        /**
1570         * {@inheritDoc}
1571         */
1572        public void removeIdentityMapper(String name)
1573            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1574            OperationRejectedException, AuthorizationException, CommunicationException {
1575          impl.removeChild(INSTANCE.getIdentityMappersRelationDefinition(), name);
1576        }
1577    
1578    
1579    
1580        /**
1581         * {@inheritDoc}
1582         */
1583        public String[] listKeyManagerProviders() throws ConcurrentModificationException,
1584            AuthorizationException, CommunicationException {
1585          return impl.listChildren(INSTANCE.getKeyManagerProvidersRelationDefinition());
1586        }
1587    
1588    
1589    
1590        /**
1591         * {@inheritDoc}
1592         */
1593        public KeyManagerProviderCfgClient getKeyManagerProvider(String name)
1594            throws DefinitionDecodingException, ManagedObjectDecodingException,
1595            ManagedObjectNotFoundException, ConcurrentModificationException,
1596            AuthorizationException, CommunicationException {
1597          return impl.getChild(INSTANCE.getKeyManagerProvidersRelationDefinition(), name).getConfiguration();
1598        }
1599    
1600    
1601    
1602        /**
1603         * {@inheritDoc}
1604         */
1605        public <M extends KeyManagerProviderCfgClient> M createKeyManagerProvider(
1606            ManagedObjectDefinition<M, ? extends KeyManagerProviderCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1607          return impl.createChild(INSTANCE.getKeyManagerProvidersRelationDefinition(), d, name, exceptions).getConfiguration();
1608        }
1609    
1610    
1611    
1612        /**
1613         * {@inheritDoc}
1614         */
1615        public void removeKeyManagerProvider(String name)
1616            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1617            OperationRejectedException, AuthorizationException, CommunicationException {
1618          impl.removeChild(INSTANCE.getKeyManagerProvidersRelationDefinition(), name);
1619        }
1620    
1621    
1622    
1623        /**
1624         * {@inheritDoc}
1625         */
1626        public String[] listLogPublishers() throws ConcurrentModificationException,
1627            AuthorizationException, CommunicationException {
1628          return impl.listChildren(INSTANCE.getLogPublishersRelationDefinition());
1629        }
1630    
1631    
1632    
1633        /**
1634         * {@inheritDoc}
1635         */
1636        public LogPublisherCfgClient getLogPublisher(String name)
1637            throws DefinitionDecodingException, ManagedObjectDecodingException,
1638            ManagedObjectNotFoundException, ConcurrentModificationException,
1639            AuthorizationException, CommunicationException {
1640          return impl.getChild(INSTANCE.getLogPublishersRelationDefinition(), name).getConfiguration();
1641        }
1642    
1643    
1644    
1645        /**
1646         * {@inheritDoc}
1647         */
1648        public <M extends LogPublisherCfgClient> M createLogPublisher(
1649            ManagedObjectDefinition<M, ? extends LogPublisherCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1650          return impl.createChild(INSTANCE.getLogPublishersRelationDefinition(), d, name, exceptions).getConfiguration();
1651        }
1652    
1653    
1654    
1655        /**
1656         * {@inheritDoc}
1657         */
1658        public void removeLogPublisher(String name)
1659            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1660            OperationRejectedException, AuthorizationException, CommunicationException {
1661          impl.removeChild(INSTANCE.getLogPublishersRelationDefinition(), name);
1662        }
1663    
1664    
1665    
1666        /**
1667         * {@inheritDoc}
1668         */
1669        public String[] listLogRetentionPolicies() throws ConcurrentModificationException,
1670            AuthorizationException, CommunicationException {
1671          return impl.listChildren(INSTANCE.getLogRetentionPoliciesRelationDefinition());
1672        }
1673    
1674    
1675    
1676        /**
1677         * {@inheritDoc}
1678         */
1679        public LogRetentionPolicyCfgClient getLogRetentionPolicy(String name)
1680            throws DefinitionDecodingException, ManagedObjectDecodingException,
1681            ManagedObjectNotFoundException, ConcurrentModificationException,
1682            AuthorizationException, CommunicationException {
1683          return impl.getChild(INSTANCE.getLogRetentionPoliciesRelationDefinition(), name).getConfiguration();
1684        }
1685    
1686    
1687    
1688        /**
1689         * {@inheritDoc}
1690         */
1691        public <M extends LogRetentionPolicyCfgClient> M createLogRetentionPolicy(
1692            ManagedObjectDefinition<M, ? extends LogRetentionPolicyCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1693          return impl.createChild(INSTANCE.getLogRetentionPoliciesRelationDefinition(), d, name, exceptions).getConfiguration();
1694        }
1695    
1696    
1697    
1698        /**
1699         * {@inheritDoc}
1700         */
1701        public void removeLogRetentionPolicy(String name)
1702            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1703            OperationRejectedException, AuthorizationException, CommunicationException {
1704          impl.removeChild(INSTANCE.getLogRetentionPoliciesRelationDefinition(), name);
1705        }
1706    
1707    
1708    
1709        /**
1710         * {@inheritDoc}
1711         */
1712        public String[] listLogRotationPolicies() throws ConcurrentModificationException,
1713            AuthorizationException, CommunicationException {
1714          return impl.listChildren(INSTANCE.getLogRotationPoliciesRelationDefinition());
1715        }
1716    
1717    
1718    
1719        /**
1720         * {@inheritDoc}
1721         */
1722        public LogRotationPolicyCfgClient getLogRotationPolicy(String name)
1723            throws DefinitionDecodingException, ManagedObjectDecodingException,
1724            ManagedObjectNotFoundException, ConcurrentModificationException,
1725            AuthorizationException, CommunicationException {
1726          return impl.getChild(INSTANCE.getLogRotationPoliciesRelationDefinition(), name).getConfiguration();
1727        }
1728    
1729    
1730    
1731        /**
1732         * {@inheritDoc}
1733         */
1734        public <M extends LogRotationPolicyCfgClient> M createLogRotationPolicy(
1735            ManagedObjectDefinition<M, ? extends LogRotationPolicyCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1736          return impl.createChild(INSTANCE.getLogRotationPoliciesRelationDefinition(), d, name, exceptions).getConfiguration();
1737        }
1738    
1739    
1740    
1741        /**
1742         * {@inheritDoc}
1743         */
1744        public void removeLogRotationPolicy(String name)
1745            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1746            OperationRejectedException, AuthorizationException, CommunicationException {
1747          impl.removeChild(INSTANCE.getLogRotationPoliciesRelationDefinition(), name);
1748        }
1749    
1750    
1751    
1752        /**
1753         * {@inheritDoc}
1754         */
1755        public String[] listMatchingRules() throws ConcurrentModificationException,
1756            AuthorizationException, CommunicationException {
1757          return impl.listChildren(INSTANCE.getMatchingRulesRelationDefinition());
1758        }
1759    
1760    
1761    
1762        /**
1763         * {@inheritDoc}
1764         */
1765        public MatchingRuleCfgClient getMatchingRule(String name)
1766            throws DefinitionDecodingException, ManagedObjectDecodingException,
1767            ManagedObjectNotFoundException, ConcurrentModificationException,
1768            AuthorizationException, CommunicationException {
1769          return impl.getChild(INSTANCE.getMatchingRulesRelationDefinition(), name).getConfiguration();
1770        }
1771    
1772    
1773    
1774        /**
1775         * {@inheritDoc}
1776         */
1777        public <M extends MatchingRuleCfgClient> M createMatchingRule(
1778            ManagedObjectDefinition<M, ? extends MatchingRuleCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1779          return impl.createChild(INSTANCE.getMatchingRulesRelationDefinition(), d, name, exceptions).getConfiguration();
1780        }
1781    
1782    
1783    
1784        /**
1785         * {@inheritDoc}
1786         */
1787        public void removeMatchingRule(String name)
1788            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1789            OperationRejectedException, AuthorizationException, CommunicationException {
1790          impl.removeChild(INSTANCE.getMatchingRulesRelationDefinition(), name);
1791        }
1792    
1793    
1794    
1795        /**
1796         * {@inheritDoc}
1797         */
1798        public String[] listMonitorProviders() throws ConcurrentModificationException,
1799            AuthorizationException, CommunicationException {
1800          return impl.listChildren(INSTANCE.getMonitorProvidersRelationDefinition());
1801        }
1802    
1803    
1804    
1805        /**
1806         * {@inheritDoc}
1807         */
1808        public MonitorProviderCfgClient getMonitorProvider(String name)
1809            throws DefinitionDecodingException, ManagedObjectDecodingException,
1810            ManagedObjectNotFoundException, ConcurrentModificationException,
1811            AuthorizationException, CommunicationException {
1812          return impl.getChild(INSTANCE.getMonitorProvidersRelationDefinition(), name).getConfiguration();
1813        }
1814    
1815    
1816    
1817        /**
1818         * {@inheritDoc}
1819         */
1820        public <M extends MonitorProviderCfgClient> M createMonitorProvider(
1821            ManagedObjectDefinition<M, ? extends MonitorProviderCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1822          return impl.createChild(INSTANCE.getMonitorProvidersRelationDefinition(), d, name, exceptions).getConfiguration();
1823        }
1824    
1825    
1826    
1827        /**
1828         * {@inheritDoc}
1829         */
1830        public void removeMonitorProvider(String name)
1831            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1832            OperationRejectedException, AuthorizationException, CommunicationException {
1833          impl.removeChild(INSTANCE.getMonitorProvidersRelationDefinition(), name);
1834        }
1835    
1836    
1837    
1838        /**
1839         * {@inheritDoc}
1840         */
1841        public String[] listNetworkGroups() throws ConcurrentModificationException,
1842            AuthorizationException, CommunicationException {
1843          return impl.listChildren(INSTANCE.getNetworkGroupsRelationDefinition());
1844        }
1845    
1846    
1847    
1848        /**
1849         * {@inheritDoc}
1850         */
1851        public NetworkGroupCfgClient getNetworkGroup(String name)
1852            throws DefinitionDecodingException, ManagedObjectDecodingException,
1853            ManagedObjectNotFoundException, ConcurrentModificationException,
1854            AuthorizationException, CommunicationException {
1855          return impl.getChild(INSTANCE.getNetworkGroupsRelationDefinition(), name).getConfiguration();
1856        }
1857    
1858    
1859    
1860        /**
1861         * {@inheritDoc}
1862         */
1863        public <M extends NetworkGroupCfgClient> M createNetworkGroup(
1864            ManagedObjectDefinition<M, ? extends NetworkGroupCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1865          return impl.createChild(INSTANCE.getNetworkGroupsRelationDefinition(), d, name, exceptions).getConfiguration();
1866        }
1867    
1868    
1869    
1870        /**
1871         * {@inheritDoc}
1872         */
1873        public void removeNetworkGroup(String name)
1874            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1875            OperationRejectedException, AuthorizationException, CommunicationException {
1876          impl.removeChild(INSTANCE.getNetworkGroupsRelationDefinition(), name);
1877        }
1878    
1879    
1880    
1881        /**
1882         * {@inheritDoc}
1883         */
1884        public String[] listPasswordGenerators() throws ConcurrentModificationException,
1885            AuthorizationException, CommunicationException {
1886          return impl.listChildren(INSTANCE.getPasswordGeneratorsRelationDefinition());
1887        }
1888    
1889    
1890    
1891        /**
1892         * {@inheritDoc}
1893         */
1894        public PasswordGeneratorCfgClient getPasswordGenerator(String name)
1895            throws DefinitionDecodingException, ManagedObjectDecodingException,
1896            ManagedObjectNotFoundException, ConcurrentModificationException,
1897            AuthorizationException, CommunicationException {
1898          return impl.getChild(INSTANCE.getPasswordGeneratorsRelationDefinition(), name).getConfiguration();
1899        }
1900    
1901    
1902    
1903        /**
1904         * {@inheritDoc}
1905         */
1906        public <M extends PasswordGeneratorCfgClient> M createPasswordGenerator(
1907            ManagedObjectDefinition<M, ? extends PasswordGeneratorCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1908          return impl.createChild(INSTANCE.getPasswordGeneratorsRelationDefinition(), d, name, exceptions).getConfiguration();
1909        }
1910    
1911    
1912    
1913        /**
1914         * {@inheritDoc}
1915         */
1916        public void removePasswordGenerator(String name)
1917            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1918            OperationRejectedException, AuthorizationException, CommunicationException {
1919          impl.removeChild(INSTANCE.getPasswordGeneratorsRelationDefinition(), name);
1920        }
1921    
1922    
1923    
1924        /**
1925         * {@inheritDoc}
1926         */
1927        public String[] listPasswordPolicies() throws ConcurrentModificationException,
1928            AuthorizationException, CommunicationException {
1929          return impl.listChildren(INSTANCE.getPasswordPoliciesRelationDefinition());
1930        }
1931    
1932    
1933    
1934        /**
1935         * {@inheritDoc}
1936         */
1937        public PasswordPolicyCfgClient getPasswordPolicy(String name)
1938            throws DefinitionDecodingException, ManagedObjectDecodingException,
1939            ManagedObjectNotFoundException, ConcurrentModificationException,
1940            AuthorizationException, CommunicationException {
1941          return impl.getChild(INSTANCE.getPasswordPoliciesRelationDefinition(), name).getConfiguration();
1942        }
1943    
1944    
1945    
1946        /**
1947         * {@inheritDoc}
1948         */
1949        public <M extends PasswordPolicyCfgClient> M createPasswordPolicy(
1950            ManagedObjectDefinition<M, ? extends PasswordPolicyCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1951          return impl.createChild(INSTANCE.getPasswordPoliciesRelationDefinition(), d, name, exceptions).getConfiguration();
1952        }
1953    
1954    
1955    
1956        /**
1957         * {@inheritDoc}
1958         */
1959        public void removePasswordPolicy(String name)
1960            throws ManagedObjectNotFoundException, ConcurrentModificationException,
1961            OperationRejectedException, AuthorizationException, CommunicationException {
1962          impl.removeChild(INSTANCE.getPasswordPoliciesRelationDefinition(), name);
1963        }
1964    
1965    
1966    
1967        /**
1968         * {@inheritDoc}
1969         */
1970        public String[] listPasswordStorageSchemes() throws ConcurrentModificationException,
1971            AuthorizationException, CommunicationException {
1972          return impl.listChildren(INSTANCE.getPasswordStorageSchemesRelationDefinition());
1973        }
1974    
1975    
1976    
1977        /**
1978         * {@inheritDoc}
1979         */
1980        public PasswordStorageSchemeCfgClient getPasswordStorageScheme(String name)
1981            throws DefinitionDecodingException, ManagedObjectDecodingException,
1982            ManagedObjectNotFoundException, ConcurrentModificationException,
1983            AuthorizationException, CommunicationException {
1984          return impl.getChild(INSTANCE.getPasswordStorageSchemesRelationDefinition(), name).getConfiguration();
1985        }
1986    
1987    
1988    
1989        /**
1990         * {@inheritDoc}
1991         */
1992        public <M extends PasswordStorageSchemeCfgClient> M createPasswordStorageScheme(
1993            ManagedObjectDefinition<M, ? extends PasswordStorageSchemeCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1994          return impl.createChild(INSTANCE.getPasswordStorageSchemesRelationDefinition(), d, name, exceptions).getConfiguration();
1995        }
1996    
1997    
1998    
1999        /**
2000         * {@inheritDoc}
2001         */
2002        public void removePasswordStorageScheme(String name)
2003            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2004            OperationRejectedException, AuthorizationException, CommunicationException {
2005          impl.removeChild(INSTANCE.getPasswordStorageSchemesRelationDefinition(), name);
2006        }
2007    
2008    
2009    
2010        /**
2011         * {@inheritDoc}
2012         */
2013        public String[] listPasswordValidators() throws ConcurrentModificationException,
2014            AuthorizationException, CommunicationException {
2015          return impl.listChildren(INSTANCE.getPasswordValidatorsRelationDefinition());
2016        }
2017    
2018    
2019    
2020        /**
2021         * {@inheritDoc}
2022         */
2023        public PasswordValidatorCfgClient getPasswordValidator(String name)
2024            throws DefinitionDecodingException, ManagedObjectDecodingException,
2025            ManagedObjectNotFoundException, ConcurrentModificationException,
2026            AuthorizationException, CommunicationException {
2027          return impl.getChild(INSTANCE.getPasswordValidatorsRelationDefinition(), name).getConfiguration();
2028        }
2029    
2030    
2031    
2032        /**
2033         * {@inheritDoc}
2034         */
2035        public <M extends PasswordValidatorCfgClient> M createPasswordValidator(
2036            ManagedObjectDefinition<M, ? extends PasswordValidatorCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2037          return impl.createChild(INSTANCE.getPasswordValidatorsRelationDefinition(), d, name, exceptions).getConfiguration();
2038        }
2039    
2040    
2041    
2042        /**
2043         * {@inheritDoc}
2044         */
2045        public void removePasswordValidator(String name)
2046            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2047            OperationRejectedException, AuthorizationException, CommunicationException {
2048          impl.removeChild(INSTANCE.getPasswordValidatorsRelationDefinition(), name);
2049        }
2050    
2051    
2052    
2053        /**
2054         * {@inheritDoc}
2055         */
2056        public PluginRootCfgClient getPluginRoot()
2057            throws DefinitionDecodingException, ManagedObjectDecodingException,
2058            ManagedObjectNotFoundException, ConcurrentModificationException,
2059            AuthorizationException, CommunicationException {
2060          return impl.getChild(INSTANCE.getPluginRootRelationDefinition()).getConfiguration();
2061        }
2062    
2063    
2064    
2065        /**
2066         * {@inheritDoc}
2067         */
2068        public RootDNCfgClient getRootDN()
2069            throws DefinitionDecodingException, ManagedObjectDecodingException,
2070            ManagedObjectNotFoundException, ConcurrentModificationException,
2071            AuthorizationException, CommunicationException {
2072          return impl.getChild(INSTANCE.getRootDNRelationDefinition()).getConfiguration();
2073        }
2074    
2075    
2076    
2077        /**
2078         * {@inheritDoc}
2079         */
2080        public RootDSEBackendCfgClient getRootDSEBackend()
2081            throws DefinitionDecodingException, ManagedObjectDecodingException,
2082            ManagedObjectNotFoundException, ConcurrentModificationException,
2083            AuthorizationException, CommunicationException {
2084          return impl.getChild(INSTANCE.getRootDSEBackendRelationDefinition()).getConfiguration();
2085        }
2086    
2087    
2088    
2089        /**
2090         * {@inheritDoc}
2091         */
2092        public String[] listSASLMechanismHandlers() throws ConcurrentModificationException,
2093            AuthorizationException, CommunicationException {
2094          return impl.listChildren(INSTANCE.getSASLMechanismHandlersRelationDefinition());
2095        }
2096    
2097    
2098    
2099        /**
2100         * {@inheritDoc}
2101         */
2102        public SASLMechanismHandlerCfgClient getSASLMechanismHandler(String name)
2103            throws DefinitionDecodingException, ManagedObjectDecodingException,
2104            ManagedObjectNotFoundException, ConcurrentModificationException,
2105            AuthorizationException, CommunicationException {
2106          return impl.getChild(INSTANCE.getSASLMechanismHandlersRelationDefinition(), name).getConfiguration();
2107        }
2108    
2109    
2110    
2111        /**
2112         * {@inheritDoc}
2113         */
2114        public <M extends SASLMechanismHandlerCfgClient> M createSASLMechanismHandler(
2115            ManagedObjectDefinition<M, ? extends SASLMechanismHandlerCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2116          return impl.createChild(INSTANCE.getSASLMechanismHandlersRelationDefinition(), d, name, exceptions).getConfiguration();
2117        }
2118    
2119    
2120    
2121        /**
2122         * {@inheritDoc}
2123         */
2124        public void removeSASLMechanismHandler(String name)
2125            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2126            OperationRejectedException, AuthorizationException, CommunicationException {
2127          impl.removeChild(INSTANCE.getSASLMechanismHandlersRelationDefinition(), name);
2128        }
2129    
2130    
2131    
2132        /**
2133         * {@inheritDoc}
2134         */
2135        public String[] listSynchronizationProviders() throws ConcurrentModificationException,
2136            AuthorizationException, CommunicationException {
2137          return impl.listChildren(INSTANCE.getSynchronizationProvidersRelationDefinition());
2138        }
2139    
2140    
2141    
2142        /**
2143         * {@inheritDoc}
2144         */
2145        public SynchronizationProviderCfgClient getSynchronizationProvider(String name)
2146            throws DefinitionDecodingException, ManagedObjectDecodingException,
2147            ManagedObjectNotFoundException, ConcurrentModificationException,
2148            AuthorizationException, CommunicationException {
2149          return impl.getChild(INSTANCE.getSynchronizationProvidersRelationDefinition(), name).getConfiguration();
2150        }
2151    
2152    
2153    
2154        /**
2155         * {@inheritDoc}
2156         */
2157        public <M extends SynchronizationProviderCfgClient> M createSynchronizationProvider(
2158            ManagedObjectDefinition<M, ? extends SynchronizationProviderCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2159          return impl.createChild(INSTANCE.getSynchronizationProvidersRelationDefinition(), d, name, exceptions).getConfiguration();
2160        }
2161    
2162    
2163    
2164        /**
2165         * {@inheritDoc}
2166         */
2167        public void removeSynchronizationProvider(String name)
2168            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2169            OperationRejectedException, AuthorizationException, CommunicationException {
2170          impl.removeChild(INSTANCE.getSynchronizationProvidersRelationDefinition(), name);
2171        }
2172    
2173    
2174    
2175        /**
2176         * {@inheritDoc}
2177         */
2178        public String[] listTrustManagerProviders() throws ConcurrentModificationException,
2179            AuthorizationException, CommunicationException {
2180          return impl.listChildren(INSTANCE.getTrustManagerProvidersRelationDefinition());
2181        }
2182    
2183    
2184    
2185        /**
2186         * {@inheritDoc}
2187         */
2188        public TrustManagerProviderCfgClient getTrustManagerProvider(String name)
2189            throws DefinitionDecodingException, ManagedObjectDecodingException,
2190            ManagedObjectNotFoundException, ConcurrentModificationException,
2191            AuthorizationException, CommunicationException {
2192          return impl.getChild(INSTANCE.getTrustManagerProvidersRelationDefinition(), name).getConfiguration();
2193        }
2194    
2195    
2196    
2197        /**
2198         * {@inheritDoc}
2199         */
2200        public <M extends TrustManagerProviderCfgClient> M createTrustManagerProvider(
2201            ManagedObjectDefinition<M, ? extends TrustManagerProviderCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2202          return impl.createChild(INSTANCE.getTrustManagerProvidersRelationDefinition(), d, name, exceptions).getConfiguration();
2203        }
2204    
2205    
2206    
2207        /**
2208         * {@inheritDoc}
2209         */
2210        public void removeTrustManagerProvider(String name)
2211            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2212            OperationRejectedException, AuthorizationException, CommunicationException {
2213          impl.removeChild(INSTANCE.getTrustManagerProvidersRelationDefinition(), name);
2214        }
2215    
2216    
2217    
2218        /**
2219         * {@inheritDoc}
2220         */
2221        public String[] listVirtualAttributes() throws ConcurrentModificationException,
2222            AuthorizationException, CommunicationException {
2223          return impl.listChildren(INSTANCE.getVirtualAttributesRelationDefinition());
2224        }
2225    
2226    
2227    
2228        /**
2229         * {@inheritDoc}
2230         */
2231        public VirtualAttributeCfgClient getVirtualAttribute(String name)
2232            throws DefinitionDecodingException, ManagedObjectDecodingException,
2233            ManagedObjectNotFoundException, ConcurrentModificationException,
2234            AuthorizationException, CommunicationException {
2235          return impl.getChild(INSTANCE.getVirtualAttributesRelationDefinition(), name).getConfiguration();
2236        }
2237    
2238    
2239    
2240        /**
2241         * {@inheritDoc}
2242         */
2243        public <M extends VirtualAttributeCfgClient> M createVirtualAttribute(
2244            ManagedObjectDefinition<M, ? extends VirtualAttributeCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2245          return impl.createChild(INSTANCE.getVirtualAttributesRelationDefinition(), d, name, exceptions).getConfiguration();
2246        }
2247    
2248    
2249    
2250        /**
2251         * {@inheritDoc}
2252         */
2253        public void removeVirtualAttribute(String name)
2254            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2255            OperationRejectedException, AuthorizationException, CommunicationException {
2256          impl.removeChild(INSTANCE.getVirtualAttributesRelationDefinition(), name);
2257        }
2258    
2259    
2260    
2261        /**
2262         * {@inheritDoc}
2263         */
2264        public String[] listWorkflows() throws ConcurrentModificationException,
2265            AuthorizationException, CommunicationException {
2266          return impl.listChildren(INSTANCE.getWorkflowsRelationDefinition());
2267        }
2268    
2269    
2270    
2271        /**
2272         * {@inheritDoc}
2273         */
2274        public WorkflowCfgClient getWorkflow(String name)
2275            throws DefinitionDecodingException, ManagedObjectDecodingException,
2276            ManagedObjectNotFoundException, ConcurrentModificationException,
2277            AuthorizationException, CommunicationException {
2278          return impl.getChild(INSTANCE.getWorkflowsRelationDefinition(), name).getConfiguration();
2279        }
2280    
2281    
2282    
2283        /**
2284         * {@inheritDoc}
2285         */
2286        public <M extends WorkflowCfgClient> M createWorkflow(
2287            ManagedObjectDefinition<M, ? extends WorkflowCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2288          return impl.createChild(INSTANCE.getWorkflowsRelationDefinition(), d, name, exceptions).getConfiguration();
2289        }
2290    
2291    
2292    
2293        /**
2294         * {@inheritDoc}
2295         */
2296        public void removeWorkflow(String name)
2297            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2298            OperationRejectedException, AuthorizationException, CommunicationException {
2299          impl.removeChild(INSTANCE.getWorkflowsRelationDefinition(), name);
2300        }
2301    
2302    
2303    
2304        /**
2305         * {@inheritDoc}
2306         */
2307        public String[] listWorkflowElements() throws ConcurrentModificationException,
2308            AuthorizationException, CommunicationException {
2309          return impl.listChildren(INSTANCE.getWorkflowElementsRelationDefinition());
2310        }
2311    
2312    
2313    
2314        /**
2315         * {@inheritDoc}
2316         */
2317        public WorkflowElementCfgClient getWorkflowElement(String name)
2318            throws DefinitionDecodingException, ManagedObjectDecodingException,
2319            ManagedObjectNotFoundException, ConcurrentModificationException,
2320            AuthorizationException, CommunicationException {
2321          return impl.getChild(INSTANCE.getWorkflowElementsRelationDefinition(), name).getConfiguration();
2322        }
2323    
2324    
2325    
2326        /**
2327         * {@inheritDoc}
2328         */
2329        public <M extends WorkflowElementCfgClient> M createWorkflowElement(
2330            ManagedObjectDefinition<M, ? extends WorkflowElementCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
2331          return impl.createChild(INSTANCE.getWorkflowElementsRelationDefinition(), d, name, exceptions).getConfiguration();
2332        }
2333    
2334    
2335    
2336        /**
2337         * {@inheritDoc}
2338         */
2339        public void removeWorkflowElement(String name)
2340            throws ManagedObjectNotFoundException, ConcurrentModificationException,
2341            OperationRejectedException, AuthorizationException, CommunicationException {
2342          impl.removeChild(INSTANCE.getWorkflowElementsRelationDefinition(), name);
2343        }
2344    
2345    
2346    
2347        /**
2348         * {@inheritDoc}
2349         */
2350        public WorkQueueCfgClient getWorkQueue()
2351            throws DefinitionDecodingException, ManagedObjectDecodingException,
2352            ManagedObjectNotFoundException, ConcurrentModificationException,
2353            AuthorizationException, CommunicationException {
2354          return impl.getChild(INSTANCE.getWorkQueueRelationDefinition()).getConfiguration();
2355        }
2356    
2357    
2358    
2359        /**
2360         * {@inheritDoc}
2361         */
2362        public ManagedObjectDefinition<? extends RootCfgClient, ? extends RootCfg> definition() {
2363          return INSTANCE;
2364        }
2365    
2366    
2367    
2368        /**
2369         * {@inheritDoc}
2370         */
2371        public PropertyProvider properties() {
2372          return impl;
2373        }
2374    
2375    
2376    
2377        /**
2378         * {@inheritDoc}
2379         */
2380        public void commit() throws ManagedObjectAlreadyExistsException,
2381            MissingMandatoryPropertiesException, ConcurrentModificationException,
2382            OperationRejectedException, AuthorizationException,
2383            CommunicationException {
2384          impl.commit();
2385        }
2386    
2387      }
2388    
2389    
2390    
2391      /**
2392       * Managed object server implementation.
2393       */
2394      private static class RootCfgServerImpl implements
2395        RootCfg {
2396    
2397        // Private implementation.
2398        private ServerManagedObject<? extends RootCfg> impl;
2399    
2400    
2401    
2402        // Private constructor.
2403        private RootCfgServerImpl(ServerManagedObject<? extends RootCfg> impl) {
2404          this.impl = impl;
2405        }
2406    
2407    
2408    
2409        /**
2410         * {@inheritDoc}
2411         */
2412        public AccessControlHandlerCfg getAccessControlHandler() throws ConfigException {
2413          return impl.getChild(INSTANCE.getAccessControlHandlerRelationDefinition()).getConfiguration();
2414        }
2415    
2416    
2417    
2418        /**
2419         * {@inheritDoc}
2420         */
2421        public String[] listAccountStatusNotificationHandlers() {
2422          return impl.listChildren(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition());
2423        }
2424    
2425    
2426    
2427        /**
2428         * {@inheritDoc}
2429         */
2430        public AccountStatusNotificationHandlerCfg getAccountStatusNotificationHandler(String name) throws ConfigException {
2431          return impl.getChild(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), name).getConfiguration();
2432        }
2433    
2434    
2435    
2436        /**
2437         * {@inheritDoc}
2438         */
2439        public void addAccountStatusNotificationHandlerAddListener(
2440            ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException {
2441          impl.registerAddListener(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), listener);
2442        }
2443    
2444    
2445    
2446        /**
2447         * {@inheritDoc}
2448         */
2449        public void removeAccountStatusNotificationHandlerAddListener(
2450            ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener) {
2451          impl.deregisterAddListener(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), listener);
2452        }
2453    
2454    
2455    
2456        /**
2457         * {@inheritDoc}
2458         */
2459        public void addAccountStatusNotificationHandlerDeleteListener(
2460            ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException {
2461          impl.registerDeleteListener(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), listener);
2462        }
2463    
2464    
2465    
2466        /**
2467         * {@inheritDoc}
2468         */
2469        public void removeAccountStatusNotificationHandlerDeleteListener(
2470            ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener) {
2471          impl.deregisterDeleteListener(INSTANCE.getAccountStatusNotificationHandlersRelationDefinition(), listener);
2472        }
2473    
2474    
2475    
2476        /**
2477         * {@inheritDoc}
2478         */
2479        public String[] listAlertHandlers() {
2480          return impl.listChildren(INSTANCE.getAlertHandlersRelationDefinition());
2481        }
2482    
2483    
2484    
2485        /**
2486         * {@inheritDoc}
2487         */
2488        public AlertHandlerCfg getAlertHandler(String name) throws ConfigException {
2489          return impl.getChild(INSTANCE.getAlertHandlersRelationDefinition(), name).getConfiguration();
2490        }
2491    
2492    
2493    
2494        /**
2495         * {@inheritDoc}
2496         */
2497        public void addAlertHandlerAddListener(
2498            ConfigurationAddListener<AlertHandlerCfg> listener) throws ConfigException {
2499          impl.registerAddListener(INSTANCE.getAlertHandlersRelationDefinition(), listener);
2500        }
2501    
2502    
2503    
2504        /**
2505         * {@inheritDoc}
2506         */
2507        public void removeAlertHandlerAddListener(
2508            ConfigurationAddListener<AlertHandlerCfg> listener) {
2509          impl.deregisterAddListener(INSTANCE.getAlertHandlersRelationDefinition(), listener);
2510        }
2511    
2512    
2513    
2514        /**
2515         * {@inheritDoc}
2516         */
2517        public void addAlertHandlerDeleteListener(
2518            ConfigurationDeleteListener<AlertHandlerCfg> listener) throws ConfigException {
2519          impl.registerDeleteListener(INSTANCE.getAlertHandlersRelationDefinition(), listener);
2520        }
2521    
2522    
2523    
2524        /**
2525         * {@inheritDoc}
2526         */
2527        public void removeAlertHandlerDeleteListener(
2528            ConfigurationDeleteListener<AlertHandlerCfg> listener) {
2529          impl.deregisterDeleteListener(INSTANCE.getAlertHandlersRelationDefinition(), listener);
2530        }
2531    
2532    
2533    
2534        /**
2535         * {@inheritDoc}
2536         */
2537        public String[] listAttributeSyntaxes() {
2538          return impl.listChildren(INSTANCE.getAttributeSyntaxesRelationDefinition());
2539        }
2540    
2541    
2542    
2543        /**
2544         * {@inheritDoc}
2545         */
2546        public AttributeSyntaxCfg getAttributeSyntax(String name) throws ConfigException {
2547          return impl.getChild(INSTANCE.getAttributeSyntaxesRelationDefinition(), name).getConfiguration();
2548        }
2549    
2550    
2551    
2552        /**
2553         * {@inheritDoc}
2554         */
2555        public void addAttributeSyntaxAddListener(
2556            ConfigurationAddListener<AttributeSyntaxCfg> listener) throws ConfigException {
2557          impl.registerAddListener(INSTANCE.getAttributeSyntaxesRelationDefinition(), listener);
2558        }
2559    
2560    
2561    
2562        /**
2563         * {@inheritDoc}
2564         */
2565        public void removeAttributeSyntaxAddListener(
2566            ConfigurationAddListener<AttributeSyntaxCfg> listener) {
2567          impl.deregisterAddListener(INSTANCE.getAttributeSyntaxesRelationDefinition(), listener);
2568        }
2569    
2570    
2571    
2572        /**
2573         * {@inheritDoc}
2574         */
2575        public void addAttributeSyntaxDeleteListener(
2576            ConfigurationDeleteListener<AttributeSyntaxCfg> listener) throws ConfigException {
2577          impl.registerDeleteListener(INSTANCE.getAttributeSyntaxesRelationDefinition(), listener);
2578        }
2579    
2580    
2581    
2582        /**
2583         * {@inheritDoc}
2584         */
2585        public void removeAttributeSyntaxDeleteListener(
2586            ConfigurationDeleteListener<AttributeSyntaxCfg> listener) {
2587          impl.deregisterDeleteListener(INSTANCE.getAttributeSyntaxesRelationDefinition(), listener);
2588        }
2589    
2590    
2591    
2592        /**
2593         * {@inheritDoc}
2594         */
2595        public String[] listBackends() {
2596          return impl.listChildren(INSTANCE.getBackendsRelationDefinition());
2597        }
2598    
2599    
2600    
2601        /**
2602         * {@inheritDoc}
2603         */
2604        public BackendCfg getBackend(String name) throws ConfigException {
2605          return impl.getChild(INSTANCE.getBackendsRelationDefinition(), name).getConfiguration();
2606        }
2607    
2608    
2609    
2610        /**
2611         * {@inheritDoc}
2612         */
2613        public void addBackendAddListener(
2614            ConfigurationAddListener<BackendCfg> listener) throws ConfigException {
2615          impl.registerAddListener(INSTANCE.getBackendsRelationDefinition(), listener);
2616        }
2617    
2618    
2619    
2620        /**
2621         * {@inheritDoc}
2622         */
2623        public void removeBackendAddListener(
2624            ConfigurationAddListener<BackendCfg> listener) {
2625          impl.deregisterAddListener(INSTANCE.getBackendsRelationDefinition(), listener);
2626        }
2627    
2628    
2629    
2630        /**
2631         * {@inheritDoc}
2632         */
2633        public void addBackendDeleteListener(
2634            ConfigurationDeleteListener<BackendCfg> listener) throws ConfigException {
2635          impl.registerDeleteListener(INSTANCE.getBackendsRelationDefinition(), listener);
2636        }
2637    
2638    
2639    
2640        /**
2641         * {@inheritDoc}
2642         */
2643        public void removeBackendDeleteListener(
2644            ConfigurationDeleteListener<BackendCfg> listener) {
2645          impl.deregisterDeleteListener(INSTANCE.getBackendsRelationDefinition(), listener);
2646        }
2647    
2648    
2649    
2650        /**
2651         * {@inheritDoc}
2652         */
2653        public String[] listCertificateMappers() {
2654          return impl.listChildren(INSTANCE.getCertificateMappersRelationDefinition());
2655        }
2656    
2657    
2658    
2659        /**
2660         * {@inheritDoc}
2661         */
2662        public CertificateMapperCfg getCertificateMapper(String name) throws ConfigException {
2663          return impl.getChild(INSTANCE.getCertificateMappersRelationDefinition(), name).getConfiguration();
2664        }
2665    
2666    
2667    
2668        /**
2669         * {@inheritDoc}
2670         */
2671        public void addCertificateMapperAddListener(
2672            ConfigurationAddListener<CertificateMapperCfg> listener) throws ConfigException {
2673          impl.registerAddListener(INSTANCE.getCertificateMappersRelationDefinition(), listener);
2674        }
2675    
2676    
2677    
2678        /**
2679         * {@inheritDoc}
2680         */
2681        public void removeCertificateMapperAddListener(
2682            ConfigurationAddListener<CertificateMapperCfg> listener) {
2683          impl.deregisterAddListener(INSTANCE.getCertificateMappersRelationDefinition(), listener);
2684        }
2685    
2686    
2687    
2688        /**
2689         * {@inheritDoc}
2690         */
2691        public void addCertificateMapperDeleteListener(
2692            ConfigurationDeleteListener<CertificateMapperCfg> listener) throws ConfigException {
2693          impl.registerDeleteListener(INSTANCE.getCertificateMappersRelationDefinition(), listener);
2694        }
2695    
2696    
2697    
2698        /**
2699         * {@inheritDoc}
2700         */
2701        public void removeCertificateMapperDeleteListener(
2702            ConfigurationDeleteListener<CertificateMapperCfg> listener) {
2703          impl.deregisterDeleteListener(INSTANCE.getCertificateMappersRelationDefinition(), listener);
2704        }
2705    
2706    
2707    
2708        /**
2709         * {@inheritDoc}
2710         */
2711        public String[] listConnectionHandlers() {
2712          return impl.listChildren(INSTANCE.getConnectionHandlersRelationDefinition());
2713        }
2714    
2715    
2716    
2717        /**
2718         * {@inheritDoc}
2719         */
2720        public ConnectionHandlerCfg getConnectionHandler(String name) throws ConfigException {
2721          return impl.getChild(INSTANCE.getConnectionHandlersRelationDefinition(), name).getConfiguration();
2722        }
2723    
2724    
2725    
2726        /**
2727         * {@inheritDoc}
2728         */
2729        public void addConnectionHandlerAddListener(
2730            ConfigurationAddListener<ConnectionHandlerCfg> listener) throws ConfigException {
2731          impl.registerAddListener(INSTANCE.getConnectionHandlersRelationDefinition(), listener);
2732        }
2733    
2734    
2735    
2736        /**
2737         * {@inheritDoc}
2738         */
2739        public void removeConnectionHandlerAddListener(
2740            ConfigurationAddListener<ConnectionHandlerCfg> listener) {
2741          impl.deregisterAddListener(INSTANCE.getConnectionHandlersRelationDefinition(), listener);
2742        }
2743    
2744    
2745    
2746        /**
2747         * {@inheritDoc}
2748         */
2749        public void addConnectionHandlerDeleteListener(
2750            ConfigurationDeleteListener<ConnectionHandlerCfg> listener) throws ConfigException {
2751          impl.registerDeleteListener(INSTANCE.getConnectionHandlersRelationDefinition(), listener);
2752        }
2753    
2754    
2755    
2756        /**
2757         * {@inheritDoc}
2758         */
2759        public void removeConnectionHandlerDeleteListener(
2760            ConfigurationDeleteListener<ConnectionHandlerCfg> listener) {
2761          impl.deregisterDeleteListener(INSTANCE.getConnectionHandlersRelationDefinition(), listener);
2762        }
2763    
2764    
2765    
2766        /**
2767         * {@inheritDoc}
2768         */
2769        public CryptoManagerCfg getCryptoManager() throws ConfigException {
2770          return impl.getChild(INSTANCE.getCryptoManagerRelationDefinition()).getConfiguration();
2771        }
2772    
2773    
2774    
2775        /**
2776         * {@inheritDoc}
2777         */
2778        public String[] listEntryCaches() {
2779          return impl.listChildren(INSTANCE.getEntryCachesRelationDefinition());
2780        }
2781    
2782    
2783    
2784        /**
2785         * {@inheritDoc}
2786         */
2787        public EntryCacheCfg getEntryCache(String name) throws ConfigException {
2788          return impl.getChild(INSTANCE.getEntryCachesRelationDefinition(), name).getConfiguration();
2789        }
2790    
2791    
2792    
2793        /**
2794         * {@inheritDoc}
2795         */
2796        public void addEntryCacheAddListener(
2797            ConfigurationAddListener<EntryCacheCfg> listener) throws ConfigException {
2798          impl.registerAddListener(INSTANCE.getEntryCachesRelationDefinition(), listener);
2799        }
2800    
2801    
2802    
2803        /**
2804         * {@inheritDoc}
2805         */
2806        public void removeEntryCacheAddListener(
2807            ConfigurationAddListener<EntryCacheCfg> listener) {
2808          impl.deregisterAddListener(INSTANCE.getEntryCachesRelationDefinition(), listener);
2809        }
2810    
2811    
2812    
2813        /**
2814         * {@inheritDoc}
2815         */
2816        public void addEntryCacheDeleteListener(
2817            ConfigurationDeleteListener<EntryCacheCfg> listener) throws ConfigException {
2818          impl.registerDeleteListener(INSTANCE.getEntryCachesRelationDefinition(), listener);
2819        }
2820    
2821    
2822    
2823        /**
2824         * {@inheritDoc}
2825         */
2826        public void removeEntryCacheDeleteListener(
2827            ConfigurationDeleteListener<EntryCacheCfg> listener) {
2828          impl.deregisterDeleteListener(INSTANCE.getEntryCachesRelationDefinition(), listener);
2829        }
2830    
2831    
2832    
2833        /**
2834         * {@inheritDoc}
2835         */
2836        public String[] listExtendedOperationHandlers() {
2837          return impl.listChildren(INSTANCE.getExtendedOperationHandlersRelationDefinition());
2838        }
2839    
2840    
2841    
2842        /**
2843         * {@inheritDoc}
2844         */
2845        public ExtendedOperationHandlerCfg getExtendedOperationHandler(String name) throws ConfigException {
2846          return impl.getChild(INSTANCE.getExtendedOperationHandlersRelationDefinition(), name).getConfiguration();
2847        }
2848    
2849    
2850    
2851        /**
2852         * {@inheritDoc}
2853         */
2854        public void addExtendedOperationHandlerAddListener(
2855            ConfigurationAddListener<ExtendedOperationHandlerCfg> listener) throws ConfigException {
2856          impl.registerAddListener(INSTANCE.getExtendedOperationHandlersRelationDefinition(), listener);
2857        }
2858    
2859    
2860    
2861        /**
2862         * {@inheritDoc}
2863         */
2864        public void removeExtendedOperationHandlerAddListener(
2865            ConfigurationAddListener<ExtendedOperationHandlerCfg> listener) {
2866          impl.deregisterAddListener(INSTANCE.getExtendedOperationHandlersRelationDefinition(), listener);
2867        }
2868    
2869    
2870    
2871        /**
2872         * {@inheritDoc}
2873         */
2874        public void addExtendedOperationHandlerDeleteListener(
2875            ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener) throws ConfigException {
2876          impl.registerDeleteListener(INSTANCE.getExtendedOperationHandlersRelationDefinition(), listener);
2877        }
2878    
2879    
2880    
2881        /**
2882         * {@inheritDoc}
2883         */
2884        public void removeExtendedOperationHandlerDeleteListener(
2885            ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener) {
2886          impl.deregisterDeleteListener(INSTANCE.getExtendedOperationHandlersRelationDefinition(), listener);
2887        }
2888    
2889    
2890    
2891        /**
2892         * {@inheritDoc}
2893         */
2894        public GlobalCfg getGlobalConfiguration() throws ConfigException {
2895          return impl.getChild(INSTANCE.getGlobalConfigurationRelationDefinition()).getConfiguration();
2896        }
2897    
2898    
2899    
2900        /**
2901         * {@inheritDoc}
2902         */
2903        public String[] listGroupImplementations() {
2904          return impl.listChildren(INSTANCE.getGroupImplementationsRelationDefinition());
2905        }
2906    
2907    
2908    
2909        /**
2910         * {@inheritDoc}
2911         */
2912        public GroupImplementationCfg getGroupImplementation(String name) throws ConfigException {
2913          return impl.getChild(INSTANCE.getGroupImplementationsRelationDefinition(), name).getConfiguration();
2914        }
2915    
2916    
2917    
2918        /**
2919         * {@inheritDoc}
2920         */
2921        public void addGroupImplementationAddListener(
2922            ConfigurationAddListener<GroupImplementationCfg> listener) throws ConfigException {
2923          impl.registerAddListener(INSTANCE.getGroupImplementationsRelationDefinition(), listener);
2924        }
2925    
2926    
2927    
2928        /**
2929         * {@inheritDoc}
2930         */
2931        public void removeGroupImplementationAddListener(
2932            ConfigurationAddListener<GroupImplementationCfg> listener) {
2933          impl.deregisterAddListener(INSTANCE.getGroupImplementationsRelationDefinition(), listener);
2934        }
2935    
2936    
2937    
2938        /**
2939         * {@inheritDoc}
2940         */
2941        public void addGroupImplementationDeleteListener(
2942            ConfigurationDeleteListener<GroupImplementationCfg> listener) throws ConfigException {
2943          impl.registerDeleteListener(INSTANCE.getGroupImplementationsRelationDefinition(), listener);
2944        }
2945    
2946    
2947    
2948        /**
2949         * {@inheritDoc}
2950         */
2951        public void removeGroupImplementationDeleteListener(
2952            ConfigurationDeleteListener<GroupImplementationCfg> listener) {
2953          impl.deregisterDeleteListener(INSTANCE.getGroupImplementationsRelationDefinition(), listener);
2954        }
2955    
2956    
2957    
2958        /**
2959         * {@inheritDoc}
2960         */
2961        public String[] listIdentityMappers() {
2962          return impl.listChildren(INSTANCE.getIdentityMappersRelationDefinition());
2963        }
2964    
2965    
2966    
2967        /**
2968         * {@inheritDoc}
2969         */
2970        public IdentityMapperCfg getIdentityMapper(String name) throws ConfigException {
2971          return impl.getChild(INSTANCE.getIdentityMappersRelationDefinition(), name).getConfiguration();
2972        }
2973    
2974    
2975    
2976        /**
2977         * {@inheritDoc}
2978         */
2979        public void addIdentityMapperAddListener(
2980            ConfigurationAddListener<IdentityMapperCfg> listener) throws ConfigException {
2981          impl.registerAddListener(INSTANCE.getIdentityMappersRelationDefinition(), listener);
2982        }
2983    
2984    
2985    
2986        /**
2987         * {@inheritDoc}
2988         */
2989        public void removeIdentityMapperAddListener(
2990            ConfigurationAddListener<IdentityMapperCfg> listener) {
2991          impl.deregisterAddListener(INSTANCE.getIdentityMappersRelationDefinition(), listener);
2992        }
2993    
2994    
2995    
2996        /**
2997         * {@inheritDoc}
2998         */
2999        public void addIdentityMapperDeleteListener(
3000            ConfigurationDeleteListener<IdentityMapperCfg> listener) throws ConfigException {
3001          impl.registerDeleteListener(INSTANCE.getIdentityMappersRelationDefinition(), listener);
3002        }
3003    
3004    
3005    
3006        /**
3007         * {@inheritDoc}
3008         */
3009        public void removeIdentityMapperDeleteListener(
3010            ConfigurationDeleteListener<IdentityMapperCfg> listener) {
3011          impl.deregisterDeleteListener(INSTANCE.getIdentityMappersRelationDefinition(), listener);
3012        }
3013    
3014    
3015    
3016        /**
3017         * {@inheritDoc}
3018         */
3019        public String[] listKeyManagerProviders() {
3020          return impl.listChildren(INSTANCE.getKeyManagerProvidersRelationDefinition());
3021        }
3022    
3023    
3024    
3025        /**
3026         * {@inheritDoc}
3027         */
3028        public KeyManagerProviderCfg getKeyManagerProvider(String name) throws ConfigException {
3029          return impl.getChild(INSTANCE.getKeyManagerProvidersRelationDefinition(), name).getConfiguration();
3030        }
3031    
3032    
3033    
3034        /**
3035         * {@inheritDoc}
3036         */
3037        public void addKeyManagerProviderAddListener(
3038            ConfigurationAddListener<KeyManagerProviderCfg> listener) throws ConfigException {
3039          impl.registerAddListener(INSTANCE.getKeyManagerProvidersRelationDefinition(), listener);
3040        }
3041    
3042    
3043    
3044        /**
3045         * {@inheritDoc}
3046         */
3047        public void removeKeyManagerProviderAddListener(
3048            ConfigurationAddListener<KeyManagerProviderCfg> listener) {
3049          impl.deregisterAddListener(INSTANCE.getKeyManagerProvidersRelationDefinition(), listener);
3050        }
3051    
3052    
3053    
3054        /**
3055         * {@inheritDoc}
3056         */
3057        public void addKeyManagerProviderDeleteListener(
3058            ConfigurationDeleteListener<KeyManagerProviderCfg> listener) throws ConfigException {
3059          impl.registerDeleteListener(INSTANCE.getKeyManagerProvidersRelationDefinition(), listener);
3060        }
3061    
3062    
3063    
3064        /**
3065         * {@inheritDoc}
3066         */
3067        public void removeKeyManagerProviderDeleteListener(
3068            ConfigurationDeleteListener<KeyManagerProviderCfg> listener) {
3069          impl.deregisterDeleteListener(INSTANCE.getKeyManagerProvidersRelationDefinition(), listener);
3070        }
3071    
3072    
3073    
3074        /**
3075         * {@inheritDoc}
3076         */
3077        public String[] listLogPublishers() {
3078          return impl.listChildren(INSTANCE.getLogPublishersRelationDefinition());
3079        }
3080    
3081    
3082    
3083        /**
3084         * {@inheritDoc}
3085         */
3086        public LogPublisherCfg getLogPublisher(String name) throws ConfigException {
3087          return impl.getChild(INSTANCE.getLogPublishersRelationDefinition(), name).getConfiguration();
3088        }
3089    
3090    
3091    
3092        /**
3093         * {@inheritDoc}
3094         */
3095        public void addLogPublisherAddListener(
3096            ConfigurationAddListener<LogPublisherCfg> listener) throws ConfigException {
3097          impl.registerAddListener(INSTANCE.getLogPublishersRelationDefinition(), listener);
3098        }
3099    
3100    
3101    
3102        /**
3103         * {@inheritDoc}
3104         */
3105        public void removeLogPublisherAddListener(
3106            ConfigurationAddListener<LogPublisherCfg> listener) {
3107          impl.deregisterAddListener(INSTANCE.getLogPublishersRelationDefinition(), listener);
3108        }
3109    
3110    
3111    
3112        /**
3113         * {@inheritDoc}
3114         */
3115        public void addLogPublisherDeleteListener(
3116            ConfigurationDeleteListener<LogPublisherCfg> listener) throws ConfigException {
3117          impl.registerDeleteListener(INSTANCE.getLogPublishersRelationDefinition(), listener);
3118        }
3119    
3120    
3121    
3122        /**
3123         * {@inheritDoc}
3124         */
3125        public void removeLogPublisherDeleteListener(
3126            ConfigurationDeleteListener<LogPublisherCfg> listener) {
3127          impl.deregisterDeleteListener(INSTANCE.getLogPublishersRelationDefinition(), listener);
3128        }
3129    
3130    
3131    
3132        /**
3133         * {@inheritDoc}
3134         */
3135        public String[] listLogRetentionPolicies() {
3136          return impl.listChildren(INSTANCE.getLogRetentionPoliciesRelationDefinition());
3137        }
3138    
3139    
3140    
3141        /**
3142         * {@inheritDoc}
3143         */
3144        public LogRetentionPolicyCfg getLogRetentionPolicy(String name) throws ConfigException {
3145          return impl.getChild(INSTANCE.getLogRetentionPoliciesRelationDefinition(), name).getConfiguration();
3146        }
3147    
3148    
3149    
3150        /**
3151         * {@inheritDoc}
3152         */
3153        public void addLogRetentionPolicyAddListener(
3154            ConfigurationAddListener<LogRetentionPolicyCfg> listener) throws ConfigException {
3155          impl.registerAddListener(INSTANCE.getLogRetentionPoliciesRelationDefinition(), listener);
3156        }
3157    
3158    
3159    
3160        /**
3161         * {@inheritDoc}
3162         */
3163        public void removeLogRetentionPolicyAddListener(
3164            ConfigurationAddListener<LogRetentionPolicyCfg> listener) {
3165          impl.deregisterAddListener(INSTANCE.getLogRetentionPoliciesRelationDefinition(), listener);
3166        }
3167    
3168    
3169    
3170        /**
3171         * {@inheritDoc}
3172         */
3173        public void addLogRetentionPolicyDeleteListener(
3174            ConfigurationDeleteListener<LogRetentionPolicyCfg> listener) throws ConfigException {
3175          impl.registerDeleteListener(INSTANCE.getLogRetentionPoliciesRelationDefinition(), listener);
3176        }
3177    
3178    
3179    
3180        /**
3181         * {@inheritDoc}
3182         */
3183        public void removeLogRetentionPolicyDeleteListener(
3184            ConfigurationDeleteListener<LogRetentionPolicyCfg> listener) {
3185          impl.deregisterDeleteListener(INSTANCE.getLogRetentionPoliciesRelationDefinition(), listener);
3186        }
3187    
3188    
3189    
3190        /**
3191         * {@inheritDoc}
3192         */
3193        public String[] listLogRotationPolicies() {
3194          return impl.listChildren(INSTANCE.getLogRotationPoliciesRelationDefinition());
3195        }
3196    
3197    
3198    
3199        /**
3200         * {@inheritDoc}
3201         */
3202        public LogRotationPolicyCfg getLogRotationPolicy(String name) throws ConfigException {
3203          return impl.getChild(INSTANCE.getLogRotationPoliciesRelationDefinition(), name).getConfiguration();
3204        }
3205    
3206    
3207    
3208        /**
3209         * {@inheritDoc}
3210         */
3211        public void addLogRotationPolicyAddListener(
3212            ConfigurationAddListener<LogRotationPolicyCfg> listener) throws ConfigException {
3213          impl.registerAddListener(INSTANCE.getLogRotationPoliciesRelationDefinition(), listener);
3214        }
3215    
3216    
3217    
3218        /**
3219         * {@inheritDoc}
3220         */
3221        public void removeLogRotationPolicyAddListener(
3222            ConfigurationAddListener<LogRotationPolicyCfg> listener) {
3223          impl.deregisterAddListener(INSTANCE.getLogRotationPoliciesRelationDefinition(), listener);
3224        }
3225    
3226    
3227    
3228        /**
3229         * {@inheritDoc}
3230         */
3231        public void addLogRotationPolicyDeleteListener(
3232            ConfigurationDeleteListener<LogRotationPolicyCfg> listener) throws ConfigException {
3233          impl.registerDeleteListener(INSTANCE.getLogRotationPoliciesRelationDefinition(), listener);
3234        }
3235    
3236    
3237    
3238        /**
3239         * {@inheritDoc}
3240         */
3241        public void removeLogRotationPolicyDeleteListener(
3242            ConfigurationDeleteListener<LogRotationPolicyCfg> listener) {
3243          impl.deregisterDeleteListener(INSTANCE.getLogRotationPoliciesRelationDefinition(), listener);
3244        }
3245    
3246    
3247    
3248        /**
3249         * {@inheritDoc}
3250         */
3251        public String[] listMatchingRules() {
3252          return impl.listChildren(INSTANCE.getMatchingRulesRelationDefinition());
3253        }
3254    
3255    
3256    
3257        /**
3258         * {@inheritDoc}
3259         */
3260        public MatchingRuleCfg getMatchingRule(String name) throws ConfigException {
3261          return impl.getChild(INSTANCE.getMatchingRulesRelationDefinition(), name).getConfiguration();
3262        }
3263    
3264    
3265    
3266        /**
3267         * {@inheritDoc}
3268         */
3269        public void addMatchingRuleAddListener(
3270            ConfigurationAddListener<MatchingRuleCfg> listener) throws ConfigException {
3271          impl.registerAddListener(INSTANCE.getMatchingRulesRelationDefinition(), listener);
3272        }
3273    
3274    
3275    
3276        /**
3277         * {@inheritDoc}
3278         */
3279        public void removeMatchingRuleAddListener(
3280            ConfigurationAddListener<MatchingRuleCfg> listener) {
3281          impl.deregisterAddListener(INSTANCE.getMatchingRulesRelationDefinition(), listener);
3282        }
3283    
3284    
3285    
3286        /**
3287         * {@inheritDoc}
3288         */
3289        public void addMatchingRuleDeleteListener(
3290            ConfigurationDeleteListener<MatchingRuleCfg> listener) throws ConfigException {
3291          impl.registerDeleteListener(INSTANCE.getMatchingRulesRelationDefinition(), listener);
3292        }
3293    
3294    
3295    
3296        /**
3297         * {@inheritDoc}
3298         */
3299        public void removeMatchingRuleDeleteListener(
3300            ConfigurationDeleteListener<MatchingRuleCfg> listener) {
3301          impl.deregisterDeleteListener(INSTANCE.getMatchingRulesRelationDefinition(), listener);
3302        }
3303    
3304    
3305    
3306        /**
3307         * {@inheritDoc}
3308         */
3309        public String[] listMonitorProviders() {
3310          return impl.listChildren(INSTANCE.getMonitorProvidersRelationDefinition());
3311        }
3312    
3313    
3314    
3315        /**
3316         * {@inheritDoc}
3317         */
3318        public MonitorProviderCfg getMonitorProvider(String name) throws ConfigException {
3319          return impl.getChild(INSTANCE.getMonitorProvidersRelationDefinition(), name).getConfiguration();
3320        }
3321    
3322    
3323    
3324        /**
3325         * {@inheritDoc}
3326         */
3327        public void addMonitorProviderAddListener(
3328            ConfigurationAddListener<MonitorProviderCfg> listener) throws ConfigException {
3329          impl.registerAddListener(INSTANCE.getMonitorProvidersRelationDefinition(), listener);
3330        }
3331    
3332    
3333    
3334        /**
3335         * {@inheritDoc}
3336         */
3337        public void removeMonitorProviderAddListener(
3338            ConfigurationAddListener<MonitorProviderCfg> listener) {
3339          impl.deregisterAddListener(INSTANCE.getMonitorProvidersRelationDefinition(), listener);
3340        }
3341    
3342    
3343    
3344        /**
3345         * {@inheritDoc}
3346         */
3347        public void addMonitorProviderDeleteListener(
3348            ConfigurationDeleteListener<MonitorProviderCfg> listener) throws ConfigException {
3349          impl.registerDeleteListener(INSTANCE.getMonitorProvidersRelationDefinition(), listener);
3350        }
3351    
3352    
3353    
3354        /**
3355         * {@inheritDoc}
3356         */
3357        public void removeMonitorProviderDeleteListener(
3358            ConfigurationDeleteListener<MonitorProviderCfg> listener) {
3359          impl.deregisterDeleteListener(INSTANCE.getMonitorProvidersRelationDefinition(), listener);
3360        }
3361    
3362    
3363    
3364        /**
3365         * {@inheritDoc}
3366         */
3367        public String[] listNetworkGroups() {
3368          return impl.listChildren(INSTANCE.getNetworkGroupsRelationDefinition());
3369        }
3370    
3371    
3372    
3373        /**
3374         * {@inheritDoc}
3375         */
3376        public NetworkGroupCfg getNetworkGroup(String name) throws ConfigException {
3377          return impl.getChild(INSTANCE.getNetworkGroupsRelationDefinition(), name).getConfiguration();
3378        }
3379    
3380    
3381    
3382        /**
3383         * {@inheritDoc}
3384         */
3385        public void addNetworkGroupAddListener(
3386            ConfigurationAddListener<NetworkGroupCfg> listener) throws ConfigException {
3387          impl.registerAddListener(INSTANCE.getNetworkGroupsRelationDefinition(), listener);
3388        }
3389    
3390    
3391    
3392        /**
3393         * {@inheritDoc}
3394         */
3395        public void removeNetworkGroupAddListener(
3396            ConfigurationAddListener<NetworkGroupCfg> listener) {
3397          impl.deregisterAddListener(INSTANCE.getNetworkGroupsRelationDefinition(), listener);
3398        }
3399    
3400    
3401    
3402        /**
3403         * {@inheritDoc}
3404         */
3405        public void addNetworkGroupDeleteListener(
3406            ConfigurationDeleteListener<NetworkGroupCfg> listener) throws ConfigException {
3407          impl.registerDeleteListener(INSTANCE.getNetworkGroupsRelationDefinition(), listener);
3408        }
3409    
3410    
3411    
3412        /**
3413         * {@inheritDoc}
3414         */
3415        public void removeNetworkGroupDeleteListener(
3416            ConfigurationDeleteListener<NetworkGroupCfg> listener) {
3417          impl.deregisterDeleteListener(INSTANCE.getNetworkGroupsRelationDefinition(), listener);
3418        }
3419    
3420    
3421    
3422        /**
3423         * {@inheritDoc}
3424         */
3425        public String[] listPasswordGenerators() {
3426          return impl.listChildren(INSTANCE.getPasswordGeneratorsRelationDefinition());
3427        }
3428    
3429    
3430    
3431        /**
3432         * {@inheritDoc}
3433         */
3434        public PasswordGeneratorCfg getPasswordGenerator(String name) throws ConfigException {
3435          return impl.getChild(INSTANCE.getPasswordGeneratorsRelationDefinition(), name).getConfiguration();
3436        }
3437    
3438    
3439    
3440        /**
3441         * {@inheritDoc}
3442         */
3443        public void addPasswordGeneratorAddListener(
3444            ConfigurationAddListener<PasswordGeneratorCfg> listener) throws ConfigException {
3445          impl.registerAddListener(INSTANCE.getPasswordGeneratorsRelationDefinition(), listener);
3446        }
3447    
3448    
3449    
3450        /**
3451         * {@inheritDoc}
3452         */
3453        public void removePasswordGeneratorAddListener(
3454            ConfigurationAddListener<PasswordGeneratorCfg> listener) {
3455          impl.deregisterAddListener(INSTANCE.getPasswordGeneratorsRelationDefinition(), listener);
3456        }
3457    
3458    
3459    
3460        /**
3461         * {@inheritDoc}
3462         */
3463        public void addPasswordGeneratorDeleteListener(
3464            ConfigurationDeleteListener<PasswordGeneratorCfg> listener) throws ConfigException {
3465          impl.registerDeleteListener(INSTANCE.getPasswordGeneratorsRelationDefinition(), listener);
3466        }
3467    
3468    
3469    
3470        /**
3471         * {@inheritDoc}
3472         */
3473        public void removePasswordGeneratorDeleteListener(
3474            ConfigurationDeleteListener<PasswordGeneratorCfg> listener) {
3475          impl.deregisterDeleteListener(INSTANCE.getPasswordGeneratorsRelationDefinition(), listener);
3476        }
3477    
3478    
3479    
3480        /**
3481         * {@inheritDoc}
3482         */
3483        public String[] listPasswordPolicies() {
3484          return impl.listChildren(INSTANCE.getPasswordPoliciesRelationDefinition());
3485        }
3486    
3487    
3488    
3489        /**
3490         * {@inheritDoc}
3491         */
3492        public PasswordPolicyCfg getPasswordPolicy(String name) throws ConfigException {
3493          return impl.getChild(INSTANCE.getPasswordPoliciesRelationDefinition(), name).getConfiguration();
3494        }
3495    
3496    
3497    
3498        /**
3499         * {@inheritDoc}
3500         */
3501        public void addPasswordPolicyAddListener(
3502            ConfigurationAddListener<PasswordPolicyCfg> listener) throws ConfigException {
3503          impl.registerAddListener(INSTANCE.getPasswordPoliciesRelationDefinition(), listener);
3504        }
3505    
3506    
3507    
3508        /**
3509         * {@inheritDoc}
3510         */
3511        public void removePasswordPolicyAddListener(
3512            ConfigurationAddListener<PasswordPolicyCfg> listener) {
3513          impl.deregisterAddListener(INSTANCE.getPasswordPoliciesRelationDefinition(), listener);
3514        }
3515    
3516    
3517    
3518        /**
3519         * {@inheritDoc}
3520         */
3521        public void addPasswordPolicyDeleteListener(
3522            ConfigurationDeleteListener<PasswordPolicyCfg> listener) throws ConfigException {
3523          impl.registerDeleteListener(INSTANCE.getPasswordPoliciesRelationDefinition(), listener);
3524        }
3525    
3526    
3527    
3528        /**
3529         * {@inheritDoc}
3530         */
3531        public void removePasswordPolicyDeleteListener(
3532            ConfigurationDeleteListener<PasswordPolicyCfg> listener) {
3533          impl.deregisterDeleteListener(INSTANCE.getPasswordPoliciesRelationDefinition(), listener);
3534        }
3535    
3536    
3537    
3538        /**
3539         * {@inheritDoc}
3540         */
3541        public String[] listPasswordStorageSchemes() {
3542          return impl.listChildren(INSTANCE.getPasswordStorageSchemesRelationDefinition());
3543        }
3544    
3545    
3546    
3547        /**
3548         * {@inheritDoc}
3549         */
3550        public PasswordStorageSchemeCfg getPasswordStorageScheme(String name) throws ConfigException {
3551          return impl.getChild(INSTANCE.getPasswordStorageSchemesRelationDefinition(), name).getConfiguration();
3552        }
3553    
3554    
3555    
3556        /**
3557         * {@inheritDoc}
3558         */
3559        public void addPasswordStorageSchemeAddListener(
3560            ConfigurationAddListener<PasswordStorageSchemeCfg> listener) throws ConfigException {
3561          impl.registerAddListener(INSTANCE.getPasswordStorageSchemesRelationDefinition(), listener);
3562        }
3563    
3564    
3565    
3566        /**
3567         * {@inheritDoc}
3568         */
3569        public void removePasswordStorageSchemeAddListener(
3570            ConfigurationAddListener<PasswordStorageSchemeCfg> listener) {
3571          impl.deregisterAddListener(INSTANCE.getPasswordStorageSchemesRelationDefinition(), listener);
3572        }
3573    
3574    
3575    
3576        /**
3577         * {@inheritDoc}
3578         */
3579        public void addPasswordStorageSchemeDeleteListener(
3580            ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener) throws ConfigException {
3581          impl.registerDeleteListener(INSTANCE.getPasswordStorageSchemesRelationDefinition(), listener);
3582        }
3583    
3584    
3585    
3586        /**
3587         * {@inheritDoc}
3588         */
3589        public void removePasswordStorageSchemeDeleteListener(
3590            ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener) {
3591          impl.deregisterDeleteListener(INSTANCE.getPasswordStorageSchemesRelationDefinition(), listener);
3592        }
3593    
3594    
3595    
3596        /**
3597         * {@inheritDoc}
3598         */
3599        public String[] listPasswordValidators() {
3600          return impl.listChildren(INSTANCE.getPasswordValidatorsRelationDefinition());
3601        }
3602    
3603    
3604    
3605        /**
3606         * {@inheritDoc}
3607         */
3608        public PasswordValidatorCfg getPasswordValidator(String name) throws ConfigException {
3609          return impl.getChild(INSTANCE.getPasswordValidatorsRelationDefinition(), name).getConfiguration();
3610        }
3611    
3612    
3613    
3614        /**
3615         * {@inheritDoc}
3616         */
3617        public void addPasswordValidatorAddListener(
3618            ConfigurationAddListener<PasswordValidatorCfg> listener) throws ConfigException {
3619          impl.registerAddListener(INSTANCE.getPasswordValidatorsRelationDefinition(), listener);
3620        }
3621    
3622    
3623    
3624        /**
3625         * {@inheritDoc}
3626         */
3627        public void removePasswordValidatorAddListener(
3628            ConfigurationAddListener<PasswordValidatorCfg> listener) {
3629          impl.deregisterAddListener(INSTANCE.getPasswordValidatorsRelationDefinition(), listener);
3630        }
3631    
3632    
3633    
3634        /**
3635         * {@inheritDoc}
3636         */
3637        public void addPasswordValidatorDeleteListener(
3638            ConfigurationDeleteListener<PasswordValidatorCfg> listener) throws ConfigException {
3639          impl.registerDeleteListener(INSTANCE.getPasswordValidatorsRelationDefinition(), listener);
3640        }
3641    
3642    
3643    
3644        /**
3645         * {@inheritDoc}
3646         */
3647        public void removePasswordValidatorDeleteListener(
3648            ConfigurationDeleteListener<PasswordValidatorCfg> listener) {
3649          impl.deregisterDeleteListener(INSTANCE.getPasswordValidatorsRelationDefinition(), listener);
3650        }
3651    
3652    
3653    
3654        /**
3655         * {@inheritDoc}
3656         */
3657        public PluginRootCfg getPluginRoot() throws ConfigException {
3658          return impl.getChild(INSTANCE.getPluginRootRelationDefinition()).getConfiguration();
3659        }
3660    
3661    
3662    
3663        /**
3664         * {@inheritDoc}
3665         */
3666        public RootDNCfg getRootDN() throws ConfigException {
3667          return impl.getChild(INSTANCE.getRootDNRelationDefinition()).getConfiguration();
3668        }
3669    
3670    
3671    
3672        /**
3673         * {@inheritDoc}
3674         */
3675        public RootDSEBackendCfg getRootDSEBackend() throws ConfigException {
3676          return impl.getChild(INSTANCE.getRootDSEBackendRelationDefinition()).getConfiguration();
3677        }
3678    
3679    
3680    
3681        /**
3682         * {@inheritDoc}
3683         */
3684        public String[] listSASLMechanismHandlers() {
3685          return impl.listChildren(INSTANCE.getSASLMechanismHandlersRelationDefinition());
3686        }
3687    
3688    
3689    
3690        /**
3691         * {@inheritDoc}
3692         */
3693        public SASLMechanismHandlerCfg getSASLMechanismHandler(String name) throws ConfigException {
3694          return impl.getChild(INSTANCE.getSASLMechanismHandlersRelationDefinition(), name).getConfiguration();
3695        }
3696    
3697    
3698    
3699        /**
3700         * {@inheritDoc}
3701         */
3702        public void addSASLMechanismHandlerAddListener(
3703            ConfigurationAddListener<SASLMechanismHandlerCfg> listener) throws ConfigException {
3704          impl.registerAddListener(INSTANCE.getSASLMechanismHandlersRelationDefinition(), listener);
3705        }
3706    
3707    
3708    
3709        /**
3710         * {@inheritDoc}
3711         */
3712        public void removeSASLMechanismHandlerAddListener(
3713            ConfigurationAddListener<SASLMechanismHandlerCfg> listener) {
3714          impl.deregisterAddListener(INSTANCE.getSASLMechanismHandlersRelationDefinition(), listener);
3715        }
3716    
3717    
3718    
3719        /**
3720         * {@inheritDoc}
3721         */
3722        public void addSASLMechanismHandlerDeleteListener(
3723            ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener) throws ConfigException {
3724          impl.registerDeleteListener(INSTANCE.getSASLMechanismHandlersRelationDefinition(), listener);
3725        }
3726    
3727    
3728    
3729        /**
3730         * {@inheritDoc}
3731         */
3732        public void removeSASLMechanismHandlerDeleteListener(
3733            ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener) {
3734          impl.deregisterDeleteListener(INSTANCE.getSASLMechanismHandlersRelationDefinition(), listener);
3735        }
3736    
3737    
3738    
3739        /**
3740         * {@inheritDoc}
3741         */
3742        public String[] listSynchronizationProviders() {
3743          return impl.listChildren(INSTANCE.getSynchronizationProvidersRelationDefinition());
3744        }
3745    
3746    
3747    
3748        /**
3749         * {@inheritDoc}
3750         */
3751        public SynchronizationProviderCfg getSynchronizationProvider(String name) throws ConfigException {
3752          return impl.getChild(INSTANCE.getSynchronizationProvidersRelationDefinition(), name).getConfiguration();
3753        }
3754    
3755    
3756    
3757        /**
3758         * {@inheritDoc}
3759         */
3760        public void addSynchronizationProviderAddListener(
3761            ConfigurationAddListener<SynchronizationProviderCfg> listener) throws ConfigException {
3762          impl.registerAddListener(INSTANCE.getSynchronizationProvidersRelationDefinition(), listener);
3763        }
3764    
3765    
3766    
3767        /**
3768         * {@inheritDoc}
3769         */
3770        public void removeSynchronizationProviderAddListener(
3771            ConfigurationAddListener<SynchronizationProviderCfg> listener) {
3772          impl.deregisterAddListener(INSTANCE.getSynchronizationProvidersRelationDefinition(), listener);
3773        }
3774    
3775    
3776    
3777        /**
3778         * {@inheritDoc}
3779         */
3780        public void addSynchronizationProviderDeleteListener(
3781            ConfigurationDeleteListener<SynchronizationProviderCfg> listener) throws ConfigException {
3782          impl.registerDeleteListener(INSTANCE.getSynchronizationProvidersRelationDefinition(), listener);
3783        }
3784    
3785    
3786    
3787        /**
3788         * {@inheritDoc}
3789         */
3790        public void removeSynchronizationProviderDeleteListener(
3791            ConfigurationDeleteListener<SynchronizationProviderCfg> listener) {
3792          impl.deregisterDeleteListener(INSTANCE.getSynchronizationProvidersRelationDefinition(), listener);
3793        }
3794    
3795    
3796    
3797        /**
3798         * {@inheritDoc}
3799         */
3800        public String[] listTrustManagerProviders() {
3801          return impl.listChildren(INSTANCE.getTrustManagerProvidersRelationDefinition());
3802        }
3803    
3804    
3805    
3806        /**
3807         * {@inheritDoc}
3808         */
3809        public TrustManagerProviderCfg getTrustManagerProvider(String name) throws ConfigException {
3810          return impl.getChild(INSTANCE.getTrustManagerProvidersRelationDefinition(), name).getConfiguration();
3811        }
3812    
3813    
3814    
3815        /**
3816         * {@inheritDoc}
3817         */
3818        public void addTrustManagerProviderAddListener(
3819            ConfigurationAddListener<TrustManagerProviderCfg> listener) throws ConfigException {
3820          impl.registerAddListener(INSTANCE.getTrustManagerProvidersRelationDefinition(), listener);
3821        }
3822    
3823    
3824    
3825        /**
3826         * {@inheritDoc}
3827         */
3828        public void removeTrustManagerProviderAddListener(
3829            ConfigurationAddListener<TrustManagerProviderCfg> listener) {
3830          impl.deregisterAddListener(INSTANCE.getTrustManagerProvidersRelationDefinition(), listener);
3831        }
3832    
3833    
3834    
3835        /**
3836         * {@inheritDoc}
3837         */
3838        public void addTrustManagerProviderDeleteListener(
3839            ConfigurationDeleteListener<TrustManagerProviderCfg> listener) throws ConfigException {
3840          impl.registerDeleteListener(INSTANCE.getTrustManagerProvidersRelationDefinition(), listener);
3841        }
3842    
3843    
3844    
3845        /**
3846         * {@inheritDoc}
3847         */
3848        public void removeTrustManagerProviderDeleteListener(
3849            ConfigurationDeleteListener<TrustManagerProviderCfg> listener) {
3850          impl.deregisterDeleteListener(INSTANCE.getTrustManagerProvidersRelationDefinition(), listener);
3851        }
3852    
3853    
3854    
3855        /**
3856         * {@inheritDoc}
3857         */
3858        public String[] listVirtualAttributes() {
3859          return impl.listChildren(INSTANCE.getVirtualAttributesRelationDefinition());
3860        }
3861    
3862    
3863    
3864        /**
3865         * {@inheritDoc}
3866         */
3867        public VirtualAttributeCfg getVirtualAttribute(String name) throws ConfigException {
3868          return impl.getChild(INSTANCE.getVirtualAttributesRelationDefinition(), name).getConfiguration();
3869        }
3870    
3871    
3872    
3873        /**
3874         * {@inheritDoc}
3875         */
3876        public void addVirtualAttributeAddListener(
3877            ConfigurationAddListener<VirtualAttributeCfg> listener) throws ConfigException {
3878          impl.registerAddListener(INSTANCE.getVirtualAttributesRelationDefinition(), listener);
3879        }
3880    
3881    
3882    
3883        /**
3884         * {@inheritDoc}
3885         */
3886        public void removeVirtualAttributeAddListener(
3887            ConfigurationAddListener<VirtualAttributeCfg> listener) {
3888          impl.deregisterAddListener(INSTANCE.getVirtualAttributesRelationDefinition(), listener);
3889        }
3890    
3891    
3892    
3893        /**
3894         * {@inheritDoc}
3895         */
3896        public void addVirtualAttributeDeleteListener(
3897            ConfigurationDeleteListener<VirtualAttributeCfg> listener) throws ConfigException {
3898          impl.registerDeleteListener(INSTANCE.getVirtualAttributesRelationDefinition(), listener);
3899        }
3900    
3901    
3902    
3903        /**
3904         * {@inheritDoc}
3905         */
3906        public void removeVirtualAttributeDeleteListener(
3907            ConfigurationDeleteListener<VirtualAttributeCfg> listener) {
3908          impl.deregisterDeleteListener(INSTANCE.getVirtualAttributesRelationDefinition(), listener);
3909        }
3910    
3911    
3912    
3913        /**
3914         * {@inheritDoc}
3915         */
3916        public String[] listWorkflows() {
3917          return impl.listChildren(INSTANCE.getWorkflowsRelationDefinition());
3918        }
3919    
3920    
3921    
3922        /**
3923         * {@inheritDoc}
3924         */
3925        public WorkflowCfg getWorkflow(String name) throws ConfigException {
3926          return impl.getChild(INSTANCE.getWorkflowsRelationDefinition(), name).getConfiguration();
3927        }
3928    
3929    
3930    
3931        /**
3932         * {@inheritDoc}
3933         */
3934        public void addWorkflowAddListener(
3935            ConfigurationAddListener<WorkflowCfg> listener) throws ConfigException {
3936          impl.registerAddListener(INSTANCE.getWorkflowsRelationDefinition(), listener);
3937        }
3938    
3939    
3940    
3941        /**
3942         * {@inheritDoc}
3943         */
3944        public void removeWorkflowAddListener(
3945            ConfigurationAddListener<WorkflowCfg> listener) {
3946          impl.deregisterAddListener(INSTANCE.getWorkflowsRelationDefinition(), listener);
3947        }
3948    
3949    
3950    
3951        /**
3952         * {@inheritDoc}
3953         */
3954        public void addWorkflowDeleteListener(
3955            ConfigurationDeleteListener<WorkflowCfg> listener) throws ConfigException {
3956          impl.registerDeleteListener(INSTANCE.getWorkflowsRelationDefinition(), listener);
3957        }
3958    
3959    
3960    
3961        /**
3962         * {@inheritDoc}
3963         */
3964        public void removeWorkflowDeleteListener(
3965            ConfigurationDeleteListener<WorkflowCfg> listener) {
3966          impl.deregisterDeleteListener(INSTANCE.getWorkflowsRelationDefinition(), listener);
3967        }
3968    
3969    
3970    
3971        /**
3972         * {@inheritDoc}
3973         */
3974        public String[] listWorkflowElements() {
3975          return impl.listChildren(INSTANCE.getWorkflowElementsRelationDefinition());
3976        }
3977    
3978    
3979    
3980        /**
3981         * {@inheritDoc}
3982         */
3983        public WorkflowElementCfg getWorkflowElement(String name) throws ConfigException {
3984          return impl.getChild(INSTANCE.getWorkflowElementsRelationDefinition(), name).getConfiguration();
3985        }
3986    
3987    
3988    
3989        /**
3990         * {@inheritDoc}
3991         */
3992        public void addWorkflowElementAddListener(
3993            ConfigurationAddListener<WorkflowElementCfg> listener) throws ConfigException {
3994          impl.registerAddListener(INSTANCE.getWorkflowElementsRelationDefinition(), listener);
3995        }
3996    
3997    
3998    
3999        /**
4000         * {@inheritDoc}
4001         */
4002        public void removeWorkflowElementAddListener(
4003            ConfigurationAddListener<WorkflowElementCfg> listener) {
4004          impl.deregisterAddListener(INSTANCE.getWorkflowElementsRelationDefinition(), listener);
4005        }
4006    
4007    
4008    
4009        /**
4010         * {@inheritDoc}
4011         */
4012        public void addWorkflowElementDeleteListener(
4013            ConfigurationDeleteListener<WorkflowElementCfg> listener) throws ConfigException {
4014          impl.registerDeleteListener(INSTANCE.getWorkflowElementsRelationDefinition(), listener);
4015        }
4016    
4017    
4018    
4019        /**
4020         * {@inheritDoc}
4021         */
4022        public void removeWorkflowElementDeleteListener(
4023            ConfigurationDeleteListener<WorkflowElementCfg> listener) {
4024          impl.deregisterDeleteListener(INSTANCE.getWorkflowElementsRelationDefinition(), listener);
4025        }
4026    
4027    
4028    
4029        /**
4030         * {@inheritDoc}
4031         */
4032        public WorkQueueCfg getWorkQueue() throws ConfigException {
4033          return impl.getChild(INSTANCE.getWorkQueueRelationDefinition()).getConfiguration();
4034        }
4035    
4036    
4037    
4038        /**
4039         * {@inheritDoc}
4040         */
4041        public Class<? extends RootCfg> configurationClass() {
4042          return RootCfg.class;
4043        }
4044    
4045    
4046    
4047        /**
4048         * {@inheritDoc}
4049         */
4050        public DN dn() {
4051          return impl.getDN();
4052        }
4053    
4054      }
4055    }