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