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