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