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