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