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