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