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