001/* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt 010 * or http://forgerock.org/license/CDDLv1.0.html. 011 * See the License for the specific language governing permissions 012 * and limitations under the License. 013 * 014 * When distributing Covered Code, include this CDDL HEADER in each 015 * file and include the License file at legal-notices/CDDLv1_0.txt. 016 * If applicable, add the following below this CDDL HEADER, with the 017 * fields enclosed by brackets "[]" replaced with your own identifying 018 * information: 019 * Portions Copyright [yyyy] [name of copyright owner] 020 * 021 * CDDL HEADER END 022 * 023 * 024 * Copyright 2008 Sun Microsystems, Inc. 025 */ 026package org.opends.server.admin.std.server; 027 028 029 030import org.forgerock.opendj.config.server.ConfigException; 031import org.opends.server.admin.Configuration; 032import org.opends.server.admin.server.ConfigurationAddListener; 033import org.opends.server.admin.server.ConfigurationDeleteListener; 034 035 036 037/** 038 * A server-side interface for querying Root settings. 039 * <p> 040 * The root configuration provides an entry point to the rest of the 041 * OpenDJ configuration. 042 */ 043public interface RootCfg extends Configuration { 044 045 /** 046 * Gets the configuration class associated with this Root. 047 * 048 * @return Returns the configuration class associated with this Root. 049 */ 050 Class<? extends RootCfg> configurationClass(); 051 052 053 054 /** 055 * Gets the Access Control Handler. 056 * 057 * @return Returns the Access Control Handler. 058 * @throws ConfigException 059 * If the Access Control Handler could not be found or it could not 060 * be successfully decoded. 061 */ 062 AccessControlHandlerCfg getAccessControlHandler() throws ConfigException; 063 064 065 066 /** 067 * Lists the Account Status Notification Handlers. 068 * 069 * @return Returns an array containing the names of the 070 * Account Status Notification Handlers. 071 */ 072 String[] listAccountStatusNotificationHandlers(); 073 074 075 076 /** 077 * Gets the named Account Status Notification Handler. 078 * 079 * @param name 080 * The name of the Account Status Notification Handler to retrieve. 081 * @return Returns the named Account Status Notification Handler. 082 * @throws ConfigException 083 * If the Account Status Notification Handler could not be found or it 084 * could not be successfully decoded. 085 */ 086 AccountStatusNotificationHandlerCfg getAccountStatusNotificationHandler(String name) throws ConfigException; 087 088 089 090 /** 091 * Registers to be notified when new Account Status Notification Handlers are added. 092 * 093 * @param listener 094 * The Account Status Notification Handler configuration add listener. 095 * @throws ConfigException 096 * If the add listener could not be registered. 097 */ 098 void addAccountStatusNotificationHandlerAddListener(ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException; 099 100 101 102 /** 103 * Deregisters an existing Account Status Notification Handler configuration add listener. 104 * 105 * @param listener 106 * The Account Status Notification Handler configuration add listener. 107 */ 108 void removeAccountStatusNotificationHandlerAddListener(ConfigurationAddListener<AccountStatusNotificationHandlerCfg> listener); 109 110 111 112 /** 113 * Registers to be notified when existing Account Status Notification Handlers are deleted. 114 * 115 * @param listener 116 * The Account Status Notification Handler configuration delete listener. 117 * @throws ConfigException 118 * If the delete listener could not be registered. 119 */ 120 void addAccountStatusNotificationHandlerDeleteListener(ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener) throws ConfigException; 121 122 123 124 /** 125 * Deregisters an existing Account Status Notification Handler configuration delete listener. 126 * 127 * @param listener 128 * The Account Status Notification Handler configuration delete listener. 129 */ 130 void removeAccountStatusNotificationHandlerDeleteListener(ConfigurationDeleteListener<AccountStatusNotificationHandlerCfg> listener); 131 132 133 134 /** 135 * Gets the Administration Connector. 136 * 137 * @return Returns the Administration Connector. 138 * @throws ConfigException 139 * If the Administration Connector could not be found or it could not 140 * be successfully decoded. 141 */ 142 AdministrationConnectorCfg getAdministrationConnector() throws ConfigException; 143 144 145 146 /** 147 * Lists the Alert Handlers. 148 * 149 * @return Returns an array containing the names of the 150 * Alert Handlers. 151 */ 152 String[] listAlertHandlers(); 153 154 155 156 /** 157 * Gets the named Alert Handler. 158 * 159 * @param name 160 * The name of the Alert Handler to retrieve. 161 * @return Returns the named Alert Handler. 162 * @throws ConfigException 163 * If the Alert Handler could not be found or it 164 * could not be successfully decoded. 165 */ 166 AlertHandlerCfg getAlertHandler(String name) throws ConfigException; 167 168 169 170 /** 171 * Registers to be notified when new Alert Handlers are added. 172 * 173 * @param listener 174 * The Alert Handler configuration add listener. 175 * @throws ConfigException 176 * If the add listener could not be registered. 177 */ 178 void addAlertHandlerAddListener(ConfigurationAddListener<AlertHandlerCfg> listener) throws ConfigException; 179 180 181 182 /** 183 * Deregisters an existing Alert Handler configuration add listener. 184 * 185 * @param listener 186 * The Alert Handler configuration add listener. 187 */ 188 void removeAlertHandlerAddListener(ConfigurationAddListener<AlertHandlerCfg> listener); 189 190 191 192 /** 193 * Registers to be notified when existing Alert Handlers are deleted. 194 * 195 * @param listener 196 * The Alert Handler configuration delete listener. 197 * @throws ConfigException 198 * If the delete listener could not be registered. 199 */ 200 void addAlertHandlerDeleteListener(ConfigurationDeleteListener<AlertHandlerCfg> listener) throws ConfigException; 201 202 203 204 /** 205 * Deregisters an existing Alert Handler configuration delete listener. 206 * 207 * @param listener 208 * The Alert Handler configuration delete listener. 209 */ 210 void removeAlertHandlerDeleteListener(ConfigurationDeleteListener<AlertHandlerCfg> listener); 211 212 213 214 /** 215 * Lists the Attribute Syntaxes. 216 * 217 * @return Returns an array containing the names of the 218 * Attribute Syntaxes. 219 */ 220 String[] listAttributeSyntaxes(); 221 222 223 224 /** 225 * Gets the named Attribute Syntax. 226 * 227 * @param name 228 * The name of the Attribute Syntax to retrieve. 229 * @return Returns the named Attribute Syntax. 230 * @throws ConfigException 231 * If the Attribute Syntax could not be found or it 232 * could not be successfully decoded. 233 */ 234 AttributeSyntaxCfg getAttributeSyntax(String name) throws ConfigException; 235 236 237 238 /** 239 * Registers to be notified when new Attribute Syntaxes are added. 240 * 241 * @param listener 242 * The Attribute Syntax configuration add listener. 243 * @throws ConfigException 244 * If the add listener could not be registered. 245 */ 246 void addAttributeSyntaxAddListener(ConfigurationAddListener<AttributeSyntaxCfg> listener) throws ConfigException; 247 248 249 250 /** 251 * Deregisters an existing Attribute Syntax configuration add listener. 252 * 253 * @param listener 254 * The Attribute Syntax configuration add listener. 255 */ 256 void removeAttributeSyntaxAddListener(ConfigurationAddListener<AttributeSyntaxCfg> listener); 257 258 259 260 /** 261 * Registers to be notified when existing Attribute Syntaxes are deleted. 262 * 263 * @param listener 264 * The Attribute Syntax configuration delete listener. 265 * @throws ConfigException 266 * If the delete listener could not be registered. 267 */ 268 void addAttributeSyntaxDeleteListener(ConfigurationDeleteListener<AttributeSyntaxCfg> listener) throws ConfigException; 269 270 271 272 /** 273 * Deregisters an existing Attribute Syntax configuration delete listener. 274 * 275 * @param listener 276 * The Attribute Syntax configuration delete listener. 277 */ 278 void removeAttributeSyntaxDeleteListener(ConfigurationDeleteListener<AttributeSyntaxCfg> listener); 279 280 281 282 /** 283 * Lists the Backends. 284 * 285 * @return Returns an array containing the names of the 286 * Backends. 287 */ 288 String[] listBackends(); 289 290 291 292 /** 293 * Gets the named Backend. 294 * 295 * @param name 296 * The name of the Backend to retrieve. 297 * @return Returns the named Backend. 298 * @throws ConfigException 299 * If the Backend could not be found or it 300 * could not be successfully decoded. 301 */ 302 BackendCfg getBackend(String name) throws ConfigException; 303 304 305 306 /** 307 * Registers to be notified when new Backends are added. 308 * 309 * @param listener 310 * The Backend configuration add listener. 311 * @throws ConfigException 312 * If the add listener could not be registered. 313 */ 314 void addBackendAddListener(ConfigurationAddListener<BackendCfg> listener) throws ConfigException; 315 316 317 318 /** 319 * Deregisters an existing Backend configuration add listener. 320 * 321 * @param listener 322 * The Backend configuration add listener. 323 */ 324 void removeBackendAddListener(ConfigurationAddListener<BackendCfg> listener); 325 326 327 328 /** 329 * Registers to be notified when existing Backends are deleted. 330 * 331 * @param listener 332 * The Backend configuration delete listener. 333 * @throws ConfigException 334 * If the delete listener could not be registered. 335 */ 336 void addBackendDeleteListener(ConfigurationDeleteListener<BackendCfg> listener) throws ConfigException; 337 338 339 340 /** 341 * Deregisters an existing Backend configuration delete listener. 342 * 343 * @param listener 344 * The Backend configuration delete listener. 345 */ 346 void removeBackendDeleteListener(ConfigurationDeleteListener<BackendCfg> listener); 347 348 349 350 /** 351 * Lists the Certificate Mappers. 352 * 353 * @return Returns an array containing the names of the 354 * Certificate Mappers. 355 */ 356 String[] listCertificateMappers(); 357 358 359 360 /** 361 * Gets the named Certificate Mapper. 362 * 363 * @param name 364 * The name of the Certificate Mapper to retrieve. 365 * @return Returns the named Certificate Mapper. 366 * @throws ConfigException 367 * If the Certificate Mapper could not be found or it 368 * could not be successfully decoded. 369 */ 370 CertificateMapperCfg getCertificateMapper(String name) throws ConfigException; 371 372 373 374 /** 375 * Registers to be notified when new Certificate Mappers are added. 376 * 377 * @param listener 378 * The Certificate Mapper configuration add listener. 379 * @throws ConfigException 380 * If the add listener could not be registered. 381 */ 382 void addCertificateMapperAddListener(ConfigurationAddListener<CertificateMapperCfg> listener) throws ConfigException; 383 384 385 386 /** 387 * Deregisters an existing Certificate Mapper configuration add listener. 388 * 389 * @param listener 390 * The Certificate Mapper configuration add listener. 391 */ 392 void removeCertificateMapperAddListener(ConfigurationAddListener<CertificateMapperCfg> listener); 393 394 395 396 /** 397 * Registers to be notified when existing Certificate Mappers are deleted. 398 * 399 * @param listener 400 * The Certificate Mapper configuration delete listener. 401 * @throws ConfigException 402 * If the delete listener could not be registered. 403 */ 404 void addCertificateMapperDeleteListener(ConfigurationDeleteListener<CertificateMapperCfg> listener) throws ConfigException; 405 406 407 408 /** 409 * Deregisters an existing Certificate Mapper configuration delete listener. 410 * 411 * @param listener 412 * The Certificate Mapper configuration delete listener. 413 */ 414 void removeCertificateMapperDeleteListener(ConfigurationDeleteListener<CertificateMapperCfg> listener); 415 416 417 418 /** 419 * Lists the Connection Handlers. 420 * 421 * @return Returns an array containing the names of the 422 * Connection Handlers. 423 */ 424 String[] listConnectionHandlers(); 425 426 427 428 /** 429 * Gets the named Connection Handler. 430 * 431 * @param name 432 * The name of the Connection Handler to retrieve. 433 * @return Returns the named Connection Handler. 434 * @throws ConfigException 435 * If the Connection Handler could not be found or it 436 * could not be successfully decoded. 437 */ 438 ConnectionHandlerCfg getConnectionHandler(String name) throws ConfigException; 439 440 441 442 /** 443 * Registers to be notified when new Connection Handlers are added. 444 * 445 * @param listener 446 * The Connection Handler configuration add listener. 447 * @throws ConfigException 448 * If the add listener could not be registered. 449 */ 450 void addConnectionHandlerAddListener(ConfigurationAddListener<ConnectionHandlerCfg> listener) throws ConfigException; 451 452 453 454 /** 455 * Deregisters an existing Connection Handler configuration add listener. 456 * 457 * @param listener 458 * The Connection Handler configuration add listener. 459 */ 460 void removeConnectionHandlerAddListener(ConfigurationAddListener<ConnectionHandlerCfg> listener); 461 462 463 464 /** 465 * Registers to be notified when existing Connection Handlers are deleted. 466 * 467 * @param listener 468 * The Connection Handler configuration delete listener. 469 * @throws ConfigException 470 * If the delete listener could not be registered. 471 */ 472 void addConnectionHandlerDeleteListener(ConfigurationDeleteListener<ConnectionHandlerCfg> listener) throws ConfigException; 473 474 475 476 /** 477 * Deregisters an existing Connection Handler configuration delete listener. 478 * 479 * @param listener 480 * The Connection Handler configuration delete listener. 481 */ 482 void removeConnectionHandlerDeleteListener(ConfigurationDeleteListener<ConnectionHandlerCfg> listener); 483 484 485 486 /** 487 * Gets the Crypto Manager. 488 * 489 * @return Returns the Crypto Manager. 490 * @throws ConfigException 491 * If the Crypto Manager could not be found or it could not 492 * be successfully decoded. 493 */ 494 CryptoManagerCfg getCryptoManager() throws ConfigException; 495 496 497 498 /** 499 * Lists the Entry Caches. 500 * 501 * @return Returns an array containing the names of the 502 * Entry Caches. 503 */ 504 String[] listEntryCaches(); 505 506 507 508 /** 509 * Gets the named Entry Cache. 510 * 511 * @param name 512 * The name of the Entry Cache to retrieve. 513 * @return Returns the named Entry Cache. 514 * @throws ConfigException 515 * If the Entry Cache could not be found or it 516 * could not be successfully decoded. 517 */ 518 EntryCacheCfg getEntryCache(String name) throws ConfigException; 519 520 521 522 /** 523 * Registers to be notified when new Entry Caches are added. 524 * 525 * @param listener 526 * The Entry Cache configuration add listener. 527 * @throws ConfigException 528 * If the add listener could not be registered. 529 */ 530 void addEntryCacheAddListener(ConfigurationAddListener<EntryCacheCfg> listener) throws ConfigException; 531 532 533 534 /** 535 * Deregisters an existing Entry Cache configuration add listener. 536 * 537 * @param listener 538 * The Entry Cache configuration add listener. 539 */ 540 void removeEntryCacheAddListener(ConfigurationAddListener<EntryCacheCfg> listener); 541 542 543 544 /** 545 * Registers to be notified when existing Entry Caches are deleted. 546 * 547 * @param listener 548 * The Entry Cache configuration delete listener. 549 * @throws ConfigException 550 * If the delete listener could not be registered. 551 */ 552 void addEntryCacheDeleteListener(ConfigurationDeleteListener<EntryCacheCfg> listener) throws ConfigException; 553 554 555 556 /** 557 * Deregisters an existing Entry Cache configuration delete listener. 558 * 559 * @param listener 560 * The Entry Cache configuration delete listener. 561 */ 562 void removeEntryCacheDeleteListener(ConfigurationDeleteListener<EntryCacheCfg> listener); 563 564 565 566 /** 567 * Lists the Extended Operation Handlers. 568 * 569 * @return Returns an array containing the names of the 570 * Extended Operation Handlers. 571 */ 572 String[] listExtendedOperationHandlers(); 573 574 575 576 /** 577 * Gets the named Extended Operation Handler. 578 * 579 * @param name 580 * The name of the Extended Operation Handler to retrieve. 581 * @return Returns the named Extended Operation Handler. 582 * @throws ConfigException 583 * If the Extended Operation Handler could not be found or it 584 * could not be successfully decoded. 585 */ 586 ExtendedOperationHandlerCfg getExtendedOperationHandler(String name) throws ConfigException; 587 588 589 590 /** 591 * Registers to be notified when new Extended Operation Handlers are added. 592 * 593 * @param listener 594 * The Extended Operation Handler configuration add listener. 595 * @throws ConfigException 596 * If the add listener could not be registered. 597 */ 598 void addExtendedOperationHandlerAddListener(ConfigurationAddListener<ExtendedOperationHandlerCfg> listener) throws ConfigException; 599 600 601 602 /** 603 * Deregisters an existing Extended Operation Handler configuration add listener. 604 * 605 * @param listener 606 * The Extended Operation Handler configuration add listener. 607 */ 608 void removeExtendedOperationHandlerAddListener(ConfigurationAddListener<ExtendedOperationHandlerCfg> listener); 609 610 611 612 /** 613 * Registers to be notified when existing Extended Operation Handlers are deleted. 614 * 615 * @param listener 616 * The Extended Operation Handler configuration delete listener. 617 * @throws ConfigException 618 * If the delete listener could not be registered. 619 */ 620 void addExtendedOperationHandlerDeleteListener(ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener) throws ConfigException; 621 622 623 624 /** 625 * Deregisters an existing Extended Operation Handler configuration delete listener. 626 * 627 * @param listener 628 * The Extended Operation Handler configuration delete listener. 629 */ 630 void removeExtendedOperationHandlerDeleteListener(ConfigurationDeleteListener<ExtendedOperationHandlerCfg> listener); 631 632 633 634 /** 635 * Gets the Global Configuration. 636 * 637 * @return Returns the Global Configuration. 638 * @throws ConfigException 639 * If the Global Configuration could not be found or it could not 640 * be successfully decoded. 641 */ 642 GlobalCfg getGlobalConfiguration() throws ConfigException; 643 644 645 646 /** 647 * Lists the Group Implementations. 648 * 649 * @return Returns an array containing the names of the 650 * Group Implementations. 651 */ 652 String[] listGroupImplementations(); 653 654 655 656 /** 657 * Gets the named Group Implementation. 658 * 659 * @param name 660 * The name of the Group Implementation to retrieve. 661 * @return Returns the named Group Implementation. 662 * @throws ConfigException 663 * If the Group Implementation could not be found or it 664 * could not be successfully decoded. 665 */ 666 GroupImplementationCfg getGroupImplementation(String name) throws ConfigException; 667 668 669 670 /** 671 * Registers to be notified when new Group Implementations are added. 672 * 673 * @param listener 674 * The Group Implementation configuration add listener. 675 * @throws ConfigException 676 * If the add listener could not be registered. 677 */ 678 void addGroupImplementationAddListener(ConfigurationAddListener<GroupImplementationCfg> listener) throws ConfigException; 679 680 681 682 /** 683 * Deregisters an existing Group Implementation configuration add listener. 684 * 685 * @param listener 686 * The Group Implementation configuration add listener. 687 */ 688 void removeGroupImplementationAddListener(ConfigurationAddListener<GroupImplementationCfg> listener); 689 690 691 692 /** 693 * Registers to be notified when existing Group Implementations are deleted. 694 * 695 * @param listener 696 * The Group Implementation configuration delete listener. 697 * @throws ConfigException 698 * If the delete listener could not be registered. 699 */ 700 void addGroupImplementationDeleteListener(ConfigurationDeleteListener<GroupImplementationCfg> listener) throws ConfigException; 701 702 703 704 /** 705 * Deregisters an existing Group Implementation configuration delete listener. 706 * 707 * @param listener 708 * The Group Implementation configuration delete listener. 709 */ 710 void removeGroupImplementationDeleteListener(ConfigurationDeleteListener<GroupImplementationCfg> listener); 711 712 713 714 /** 715 * Lists the Identity Mappers. 716 * 717 * @return Returns an array containing the names of the 718 * Identity Mappers. 719 */ 720 String[] listIdentityMappers(); 721 722 723 724 /** 725 * Gets the named Identity Mapper. 726 * 727 * @param name 728 * The name of the Identity Mapper to retrieve. 729 * @return Returns the named Identity Mapper. 730 * @throws ConfigException 731 * If the Identity Mapper could not be found or it 732 * could not be successfully decoded. 733 */ 734 IdentityMapperCfg getIdentityMapper(String name) throws ConfigException; 735 736 737 738 /** 739 * Registers to be notified when new Identity Mappers are added. 740 * 741 * @param listener 742 * The Identity Mapper configuration add listener. 743 * @throws ConfigException 744 * If the add listener could not be registered. 745 */ 746 void addIdentityMapperAddListener(ConfigurationAddListener<IdentityMapperCfg> listener) throws ConfigException; 747 748 749 750 /** 751 * Deregisters an existing Identity Mapper configuration add listener. 752 * 753 * @param listener 754 * The Identity Mapper configuration add listener. 755 */ 756 void removeIdentityMapperAddListener(ConfigurationAddListener<IdentityMapperCfg> listener); 757 758 759 760 /** 761 * Registers to be notified when existing Identity Mappers are deleted. 762 * 763 * @param listener 764 * The Identity Mapper configuration delete listener. 765 * @throws ConfigException 766 * If the delete listener could not be registered. 767 */ 768 void addIdentityMapperDeleteListener(ConfigurationDeleteListener<IdentityMapperCfg> listener) throws ConfigException; 769 770 771 772 /** 773 * Deregisters an existing Identity Mapper configuration delete listener. 774 * 775 * @param listener 776 * The Identity Mapper configuration delete listener. 777 */ 778 void removeIdentityMapperDeleteListener(ConfigurationDeleteListener<IdentityMapperCfg> listener); 779 780 781 782 /** 783 * Lists the Key Manager Providers. 784 * 785 * @return Returns an array containing the names of the 786 * Key Manager Providers. 787 */ 788 String[] listKeyManagerProviders(); 789 790 791 792 /** 793 * Gets the named Key Manager Provider. 794 * 795 * @param name 796 * The name of the Key Manager Provider to retrieve. 797 * @return Returns the named Key Manager Provider. 798 * @throws ConfigException 799 * If the Key Manager Provider could not be found or it 800 * could not be successfully decoded. 801 */ 802 KeyManagerProviderCfg getKeyManagerProvider(String name) throws ConfigException; 803 804 805 806 /** 807 * Registers to be notified when new Key Manager Providers are added. 808 * 809 * @param listener 810 * The Key Manager Provider configuration add listener. 811 * @throws ConfigException 812 * If the add listener could not be registered. 813 */ 814 void addKeyManagerProviderAddListener(ConfigurationAddListener<KeyManagerProviderCfg> listener) throws ConfigException; 815 816 817 818 /** 819 * Deregisters an existing Key Manager Provider configuration add listener. 820 * 821 * @param listener 822 * The Key Manager Provider configuration add listener. 823 */ 824 void removeKeyManagerProviderAddListener(ConfigurationAddListener<KeyManagerProviderCfg> listener); 825 826 827 828 /** 829 * Registers to be notified when existing Key Manager Providers are deleted. 830 * 831 * @param listener 832 * The Key Manager Provider configuration delete listener. 833 * @throws ConfigException 834 * If the delete listener could not be registered. 835 */ 836 void addKeyManagerProviderDeleteListener(ConfigurationDeleteListener<KeyManagerProviderCfg> listener) throws ConfigException; 837 838 839 840 /** 841 * Deregisters an existing Key Manager Provider configuration delete listener. 842 * 843 * @param listener 844 * The Key Manager Provider configuration delete listener. 845 */ 846 void removeKeyManagerProviderDeleteListener(ConfigurationDeleteListener<KeyManagerProviderCfg> listener); 847 848 849 850 /** 851 * Lists the Log Publishers. 852 * 853 * @return Returns an array containing the names of the 854 * Log Publishers. 855 */ 856 String[] listLogPublishers(); 857 858 859 860 /** 861 * Gets the named Log Publisher. 862 * 863 * @param name 864 * The name of the Log Publisher to retrieve. 865 * @return Returns the named Log Publisher. 866 * @throws ConfigException 867 * If the Log Publisher could not be found or it 868 * could not be successfully decoded. 869 */ 870 LogPublisherCfg getLogPublisher(String name) throws ConfigException; 871 872 873 874 /** 875 * Registers to be notified when new Log Publishers are added. 876 * 877 * @param listener 878 * The Log Publisher configuration add listener. 879 * @throws ConfigException 880 * If the add listener could not be registered. 881 */ 882 void addLogPublisherAddListener(ConfigurationAddListener<LogPublisherCfg> listener) throws ConfigException; 883 884 885 886 /** 887 * Deregisters an existing Log Publisher configuration add listener. 888 * 889 * @param listener 890 * The Log Publisher configuration add listener. 891 */ 892 void removeLogPublisherAddListener(ConfigurationAddListener<LogPublisherCfg> listener); 893 894 895 896 /** 897 * Registers to be notified when existing Log Publishers are deleted. 898 * 899 * @param listener 900 * The Log Publisher configuration delete listener. 901 * @throws ConfigException 902 * If the delete listener could not be registered. 903 */ 904 void addLogPublisherDeleteListener(ConfigurationDeleteListener<LogPublisherCfg> listener) throws ConfigException; 905 906 907 908 /** 909 * Deregisters an existing Log Publisher configuration delete listener. 910 * 911 * @param listener 912 * The Log Publisher configuration delete listener. 913 */ 914 void removeLogPublisherDeleteListener(ConfigurationDeleteListener<LogPublisherCfg> listener); 915 916 917 918 /** 919 * Lists the Log Retention Policies. 920 * 921 * @return Returns an array containing the names of the 922 * Log Retention Policies. 923 */ 924 String[] listLogRetentionPolicies(); 925 926 927 928 /** 929 * Gets the named Log Retention Policy. 930 * 931 * @param name 932 * The name of the Log Retention Policy to retrieve. 933 * @return Returns the named Log Retention Policy. 934 * @throws ConfigException 935 * If the Log Retention Policy could not be found or it 936 * could not be successfully decoded. 937 */ 938 LogRetentionPolicyCfg getLogRetentionPolicy(String name) throws ConfigException; 939 940 941 942 /** 943 * Registers to be notified when new Log Retention Policies are added. 944 * 945 * @param listener 946 * The Log Retention Policy configuration add listener. 947 * @throws ConfigException 948 * If the add listener could not be registered. 949 */ 950 void addLogRetentionPolicyAddListener(ConfigurationAddListener<LogRetentionPolicyCfg> listener) throws ConfigException; 951 952 953 954 /** 955 * Deregisters an existing Log Retention Policy configuration add listener. 956 * 957 * @param listener 958 * The Log Retention Policy configuration add listener. 959 */ 960 void removeLogRetentionPolicyAddListener(ConfigurationAddListener<LogRetentionPolicyCfg> listener); 961 962 963 964 /** 965 * Registers to be notified when existing Log Retention Policies are deleted. 966 * 967 * @param listener 968 * The Log Retention Policy configuration delete listener. 969 * @throws ConfigException 970 * If the delete listener could not be registered. 971 */ 972 void addLogRetentionPolicyDeleteListener(ConfigurationDeleteListener<LogRetentionPolicyCfg> listener) throws ConfigException; 973 974 975 976 /** 977 * Deregisters an existing Log Retention Policy configuration delete listener. 978 * 979 * @param listener 980 * The Log Retention Policy configuration delete listener. 981 */ 982 void removeLogRetentionPolicyDeleteListener(ConfigurationDeleteListener<LogRetentionPolicyCfg> listener); 983 984 985 986 /** 987 * Lists the Log Rotation Policies. 988 * 989 * @return Returns an array containing the names of the 990 * Log Rotation Policies. 991 */ 992 String[] listLogRotationPolicies(); 993 994 995 996 /** 997 * Gets the named Log Rotation Policy. 998 * 999 * @param name 1000 * The name of the Log Rotation Policy to retrieve. 1001 * @return Returns the named Log Rotation Policy. 1002 * @throws ConfigException 1003 * If the Log Rotation Policy could not be found or it 1004 * could not be successfully decoded. 1005 */ 1006 LogRotationPolicyCfg getLogRotationPolicy(String name) throws ConfigException; 1007 1008 1009 1010 /** 1011 * Registers to be notified when new Log Rotation Policies are added. 1012 * 1013 * @param listener 1014 * The Log Rotation Policy configuration add listener. 1015 * @throws ConfigException 1016 * If the add listener could not be registered. 1017 */ 1018 void addLogRotationPolicyAddListener(ConfigurationAddListener<LogRotationPolicyCfg> listener) throws ConfigException; 1019 1020 1021 1022 /** 1023 * Deregisters an existing Log Rotation Policy configuration add listener. 1024 * 1025 * @param listener 1026 * The Log Rotation Policy configuration add listener. 1027 */ 1028 void removeLogRotationPolicyAddListener(ConfigurationAddListener<LogRotationPolicyCfg> listener); 1029 1030 1031 1032 /** 1033 * Registers to be notified when existing Log Rotation Policies are deleted. 1034 * 1035 * @param listener 1036 * The Log Rotation Policy configuration delete listener. 1037 * @throws ConfigException 1038 * If the delete listener could not be registered. 1039 */ 1040 void addLogRotationPolicyDeleteListener(ConfigurationDeleteListener<LogRotationPolicyCfg> listener) throws ConfigException; 1041 1042 1043 1044 /** 1045 * Deregisters an existing Log Rotation Policy configuration delete listener. 1046 * 1047 * @param listener 1048 * The Log Rotation Policy configuration delete listener. 1049 */ 1050 void removeLogRotationPolicyDeleteListener(ConfigurationDeleteListener<LogRotationPolicyCfg> listener); 1051 1052 1053 1054 /** 1055 * Lists the Matching Rules. 1056 * 1057 * @return Returns an array containing the names of the 1058 * Matching Rules. 1059 */ 1060 String[] listMatchingRules(); 1061 1062 1063 1064 /** 1065 * Gets the named Matching Rule. 1066 * 1067 * @param name 1068 * The name of the Matching Rule to retrieve. 1069 * @return Returns the named Matching Rule. 1070 * @throws ConfigException 1071 * If the Matching Rule could not be found or it 1072 * could not be successfully decoded. 1073 */ 1074 MatchingRuleCfg getMatchingRule(String name) throws ConfigException; 1075 1076 1077 1078 /** 1079 * Registers to be notified when new Matching Rules are added. 1080 * 1081 * @param listener 1082 * The Matching Rule configuration add listener. 1083 * @throws ConfigException 1084 * If the add listener could not be registered. 1085 */ 1086 void addMatchingRuleAddListener(ConfigurationAddListener<MatchingRuleCfg> listener) throws ConfigException; 1087 1088 1089 1090 /** 1091 * Deregisters an existing Matching Rule configuration add listener. 1092 * 1093 * @param listener 1094 * The Matching Rule configuration add listener. 1095 */ 1096 void removeMatchingRuleAddListener(ConfigurationAddListener<MatchingRuleCfg> listener); 1097 1098 1099 1100 /** 1101 * Registers to be notified when existing Matching Rules are deleted. 1102 * 1103 * @param listener 1104 * The Matching Rule configuration delete listener. 1105 * @throws ConfigException 1106 * If the delete listener could not be registered. 1107 */ 1108 void addMatchingRuleDeleteListener(ConfigurationDeleteListener<MatchingRuleCfg> listener) throws ConfigException; 1109 1110 1111 1112 /** 1113 * Deregisters an existing Matching Rule configuration delete listener. 1114 * 1115 * @param listener 1116 * The Matching Rule configuration delete listener. 1117 */ 1118 void removeMatchingRuleDeleteListener(ConfigurationDeleteListener<MatchingRuleCfg> listener); 1119 1120 1121 1122 /** 1123 * Lists the Monitor Providers. 1124 * 1125 * @return Returns an array containing the names of the 1126 * Monitor Providers. 1127 */ 1128 String[] listMonitorProviders(); 1129 1130 1131 1132 /** 1133 * Gets the named Monitor Provider. 1134 * 1135 * @param name 1136 * The name of the Monitor Provider to retrieve. 1137 * @return Returns the named Monitor Provider. 1138 * @throws ConfigException 1139 * If the Monitor Provider could not be found or it 1140 * could not be successfully decoded. 1141 */ 1142 MonitorProviderCfg getMonitorProvider(String name) throws ConfigException; 1143 1144 1145 1146 /** 1147 * Registers to be notified when new Monitor Providers are added. 1148 * 1149 * @param listener 1150 * The Monitor Provider configuration add listener. 1151 * @throws ConfigException 1152 * If the add listener could not be registered. 1153 */ 1154 void addMonitorProviderAddListener(ConfigurationAddListener<MonitorProviderCfg> listener) throws ConfigException; 1155 1156 1157 1158 /** 1159 * Deregisters an existing Monitor Provider configuration add listener. 1160 * 1161 * @param listener 1162 * The Monitor Provider configuration add listener. 1163 */ 1164 void removeMonitorProviderAddListener(ConfigurationAddListener<MonitorProviderCfg> listener); 1165 1166 1167 1168 /** 1169 * Registers to be notified when existing Monitor Providers are deleted. 1170 * 1171 * @param listener 1172 * The Monitor Provider configuration delete listener. 1173 * @throws ConfigException 1174 * If the delete listener could not be registered. 1175 */ 1176 void addMonitorProviderDeleteListener(ConfigurationDeleteListener<MonitorProviderCfg> listener) throws ConfigException; 1177 1178 1179 1180 /** 1181 * Deregisters an existing Monitor Provider configuration delete listener. 1182 * 1183 * @param listener 1184 * The Monitor Provider configuration delete listener. 1185 */ 1186 void removeMonitorProviderDeleteListener(ConfigurationDeleteListener<MonitorProviderCfg> listener); 1187 1188 1189 1190 /** 1191 * Lists the Password Generators. 1192 * 1193 * @return Returns an array containing the names of the 1194 * Password Generators. 1195 */ 1196 String[] listPasswordGenerators(); 1197 1198 1199 1200 /** 1201 * Gets the named Password Generator. 1202 * 1203 * @param name 1204 * The name of the Password Generator to retrieve. 1205 * @return Returns the named Password Generator. 1206 * @throws ConfigException 1207 * If the Password Generator could not be found or it 1208 * could not be successfully decoded. 1209 */ 1210 PasswordGeneratorCfg getPasswordGenerator(String name) throws ConfigException; 1211 1212 1213 1214 /** 1215 * Registers to be notified when new Password Generators are added. 1216 * 1217 * @param listener 1218 * The Password Generator configuration add listener. 1219 * @throws ConfigException 1220 * If the add listener could not be registered. 1221 */ 1222 void addPasswordGeneratorAddListener(ConfigurationAddListener<PasswordGeneratorCfg> listener) throws ConfigException; 1223 1224 1225 1226 /** 1227 * Deregisters an existing Password Generator configuration add listener. 1228 * 1229 * @param listener 1230 * The Password Generator configuration add listener. 1231 */ 1232 void removePasswordGeneratorAddListener(ConfigurationAddListener<PasswordGeneratorCfg> listener); 1233 1234 1235 1236 /** 1237 * Registers to be notified when existing Password Generators are deleted. 1238 * 1239 * @param listener 1240 * The Password Generator configuration delete listener. 1241 * @throws ConfigException 1242 * If the delete listener could not be registered. 1243 */ 1244 void addPasswordGeneratorDeleteListener(ConfigurationDeleteListener<PasswordGeneratorCfg> listener) throws ConfigException; 1245 1246 1247 1248 /** 1249 * Deregisters an existing Password Generator configuration delete listener. 1250 * 1251 * @param listener 1252 * The Password Generator configuration delete listener. 1253 */ 1254 void removePasswordGeneratorDeleteListener(ConfigurationDeleteListener<PasswordGeneratorCfg> listener); 1255 1256 1257 1258 /** 1259 * Lists the Password Policies. 1260 * 1261 * @return Returns an array containing the names of the 1262 * Password Policies. 1263 */ 1264 String[] listPasswordPolicies(); 1265 1266 1267 1268 /** 1269 * Gets the named Password Policy. 1270 * 1271 * @param name 1272 * The name of the Password Policy to retrieve. 1273 * @return Returns the named Password Policy. 1274 * @throws ConfigException 1275 * If the Password Policy could not be found or it 1276 * could not be successfully decoded. 1277 */ 1278 AuthenticationPolicyCfg getPasswordPolicy(String name) throws ConfigException; 1279 1280 1281 1282 /** 1283 * Registers to be notified when new Password Policies are added. 1284 * 1285 * @param listener 1286 * The Password Policy configuration add listener. 1287 * @throws ConfigException 1288 * If the add listener could not be registered. 1289 */ 1290 void addPasswordPolicyAddListener(ConfigurationAddListener<AuthenticationPolicyCfg> listener) throws ConfigException; 1291 1292 1293 1294 /** 1295 * Deregisters an existing Password Policy configuration add listener. 1296 * 1297 * @param listener 1298 * The Password Policy configuration add listener. 1299 */ 1300 void removePasswordPolicyAddListener(ConfigurationAddListener<AuthenticationPolicyCfg> listener); 1301 1302 1303 1304 /** 1305 * Registers to be notified when existing Password Policies are deleted. 1306 * 1307 * @param listener 1308 * The Password Policy configuration delete listener. 1309 * @throws ConfigException 1310 * If the delete listener could not be registered. 1311 */ 1312 void addPasswordPolicyDeleteListener(ConfigurationDeleteListener<AuthenticationPolicyCfg> listener) throws ConfigException; 1313 1314 1315 1316 /** 1317 * Deregisters an existing Password Policy configuration delete listener. 1318 * 1319 * @param listener 1320 * The Password Policy configuration delete listener. 1321 */ 1322 void removePasswordPolicyDeleteListener(ConfigurationDeleteListener<AuthenticationPolicyCfg> listener); 1323 1324 1325 1326 /** 1327 * Lists the Password Storage Schemes. 1328 * 1329 * @return Returns an array containing the names of the 1330 * Password Storage Schemes. 1331 */ 1332 String[] listPasswordStorageSchemes(); 1333 1334 1335 1336 /** 1337 * Gets the named Password Storage Scheme. 1338 * 1339 * @param name 1340 * The name of the Password Storage Scheme to retrieve. 1341 * @return Returns the named Password Storage Scheme. 1342 * @throws ConfigException 1343 * If the Password Storage Scheme could not be found or it 1344 * could not be successfully decoded. 1345 */ 1346 PasswordStorageSchemeCfg getPasswordStorageScheme(String name) throws ConfigException; 1347 1348 1349 1350 /** 1351 * Registers to be notified when new Password Storage Schemes are added. 1352 * 1353 * @param listener 1354 * The Password Storage Scheme configuration add listener. 1355 * @throws ConfigException 1356 * If the add listener could not be registered. 1357 */ 1358 void addPasswordStorageSchemeAddListener(ConfigurationAddListener<PasswordStorageSchemeCfg> listener) throws ConfigException; 1359 1360 1361 1362 /** 1363 * Deregisters an existing Password Storage Scheme configuration add listener. 1364 * 1365 * @param listener 1366 * The Password Storage Scheme configuration add listener. 1367 */ 1368 void removePasswordStorageSchemeAddListener(ConfigurationAddListener<PasswordStorageSchemeCfg> listener); 1369 1370 1371 1372 /** 1373 * Registers to be notified when existing Password Storage Schemes are deleted. 1374 * 1375 * @param listener 1376 * The Password Storage Scheme configuration delete listener. 1377 * @throws ConfigException 1378 * If the delete listener could not be registered. 1379 */ 1380 void addPasswordStorageSchemeDeleteListener(ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener) throws ConfigException; 1381 1382 1383 1384 /** 1385 * Deregisters an existing Password Storage Scheme configuration delete listener. 1386 * 1387 * @param listener 1388 * The Password Storage Scheme configuration delete listener. 1389 */ 1390 void removePasswordStorageSchemeDeleteListener(ConfigurationDeleteListener<PasswordStorageSchemeCfg> listener); 1391 1392 1393 1394 /** 1395 * Lists the Password Validators. 1396 * 1397 * @return Returns an array containing the names of the 1398 * Password Validators. 1399 */ 1400 String[] listPasswordValidators(); 1401 1402 1403 1404 /** 1405 * Gets the named Password Validator. 1406 * 1407 * @param name 1408 * The name of the Password Validator to retrieve. 1409 * @return Returns the named Password Validator. 1410 * @throws ConfigException 1411 * If the Password Validator could not be found or it 1412 * could not be successfully decoded. 1413 */ 1414 PasswordValidatorCfg getPasswordValidator(String name) throws ConfigException; 1415 1416 1417 1418 /** 1419 * Registers to be notified when new Password Validators are added. 1420 * 1421 * @param listener 1422 * The Password Validator configuration add listener. 1423 * @throws ConfigException 1424 * If the add listener could not be registered. 1425 */ 1426 void addPasswordValidatorAddListener(ConfigurationAddListener<PasswordValidatorCfg> listener) throws ConfigException; 1427 1428 1429 1430 /** 1431 * Deregisters an existing Password Validator configuration add listener. 1432 * 1433 * @param listener 1434 * The Password Validator configuration add listener. 1435 */ 1436 void removePasswordValidatorAddListener(ConfigurationAddListener<PasswordValidatorCfg> listener); 1437 1438 1439 1440 /** 1441 * Registers to be notified when existing Password Validators are deleted. 1442 * 1443 * @param listener 1444 * The Password Validator configuration delete listener. 1445 * @throws ConfigException 1446 * If the delete listener could not be registered. 1447 */ 1448 void addPasswordValidatorDeleteListener(ConfigurationDeleteListener<PasswordValidatorCfg> listener) throws ConfigException; 1449 1450 1451 1452 /** 1453 * Deregisters an existing Password Validator configuration delete listener. 1454 * 1455 * @param listener 1456 * The Password Validator configuration delete listener. 1457 */ 1458 void removePasswordValidatorDeleteListener(ConfigurationDeleteListener<PasswordValidatorCfg> listener); 1459 1460 1461 1462 /** 1463 * Gets the Plugin Root. 1464 * 1465 * @return Returns the Plugin Root. 1466 * @throws ConfigException 1467 * If the Plugin Root could not be found or it could not 1468 * be successfully decoded. 1469 */ 1470 PluginRootCfg getPluginRoot() throws ConfigException; 1471 1472 1473 1474 /** 1475 * Gets the Root DN. 1476 * 1477 * @return Returns the Root DN. 1478 * @throws ConfigException 1479 * If the Root DN could not be found or it could not 1480 * be successfully decoded. 1481 */ 1482 RootDNCfg getRootDN() throws ConfigException; 1483 1484 1485 1486 /** 1487 * Gets the Root DSE Backend. 1488 * 1489 * @return Returns the Root DSE Backend. 1490 * @throws ConfigException 1491 * If the Root DSE Backend could not be found or it could not 1492 * be successfully decoded. 1493 */ 1494 RootDSEBackendCfg getRootDSEBackend() throws ConfigException; 1495 1496 1497 1498 /** 1499 * Lists the SASL Mechanism Handlers. 1500 * 1501 * @return Returns an array containing the names of the 1502 * SASL Mechanism Handlers. 1503 */ 1504 String[] listSASLMechanismHandlers(); 1505 1506 1507 1508 /** 1509 * Gets the named SASL Mechanism Handler. 1510 * 1511 * @param name 1512 * The name of the SASL Mechanism Handler to retrieve. 1513 * @return Returns the named SASL Mechanism Handler. 1514 * @throws ConfigException 1515 * If the SASL Mechanism Handler could not be found or it 1516 * could not be successfully decoded. 1517 */ 1518 SASLMechanismHandlerCfg getSASLMechanismHandler(String name) throws ConfigException; 1519 1520 1521 1522 /** 1523 * Registers to be notified when new SASL Mechanism Handlers are added. 1524 * 1525 * @param listener 1526 * The SASL Mechanism Handler configuration add listener. 1527 * @throws ConfigException 1528 * If the add listener could not be registered. 1529 */ 1530 void addSASLMechanismHandlerAddListener(ConfigurationAddListener<SASLMechanismHandlerCfg> listener) throws ConfigException; 1531 1532 1533 1534 /** 1535 * Deregisters an existing SASL Mechanism Handler configuration add listener. 1536 * 1537 * @param listener 1538 * The SASL Mechanism Handler configuration add listener. 1539 */ 1540 void removeSASLMechanismHandlerAddListener(ConfigurationAddListener<SASLMechanismHandlerCfg> listener); 1541 1542 1543 1544 /** 1545 * Registers to be notified when existing SASL Mechanism Handlers are deleted. 1546 * 1547 * @param listener 1548 * The SASL Mechanism Handler configuration delete listener. 1549 * @throws ConfigException 1550 * If the delete listener could not be registered. 1551 */ 1552 void addSASLMechanismHandlerDeleteListener(ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener) throws ConfigException; 1553 1554 1555 1556 /** 1557 * Deregisters an existing SASL Mechanism Handler configuration delete listener. 1558 * 1559 * @param listener 1560 * The SASL Mechanism Handler configuration delete listener. 1561 */ 1562 void removeSASLMechanismHandlerDeleteListener(ConfigurationDeleteListener<SASLMechanismHandlerCfg> listener); 1563 1564 1565 1566 /** 1567 * Lists the Schema Providers. 1568 * 1569 * @return Returns an array containing the names of the 1570 * Schema Providers. 1571 */ 1572 String[] listSchemaProviders(); 1573 1574 1575 1576 /** 1577 * Gets the named Schema Provider. 1578 * 1579 * @param name 1580 * The name of the Schema Provider to retrieve. 1581 * @return Returns the named Schema Provider. 1582 * @throws ConfigException 1583 * If the Schema Provider could not be found or it 1584 * could not be successfully decoded. 1585 */ 1586 SchemaProviderCfg getSchemaProvider(String name) throws ConfigException; 1587 1588 1589 1590 /** 1591 * Registers to be notified when new Schema Providers are added. 1592 * 1593 * @param listener 1594 * The Schema Provider configuration add listener. 1595 * @throws ConfigException 1596 * If the add listener could not be registered. 1597 */ 1598 void addSchemaProviderAddListener(ConfigurationAddListener<SchemaProviderCfg> listener) throws ConfigException; 1599 1600 1601 1602 /** 1603 * Deregisters an existing Schema Provider configuration add listener. 1604 * 1605 * @param listener 1606 * The Schema Provider configuration add listener. 1607 */ 1608 void removeSchemaProviderAddListener(ConfigurationAddListener<SchemaProviderCfg> listener); 1609 1610 1611 1612 /** 1613 * Registers to be notified when existing Schema Providers are deleted. 1614 * 1615 * @param listener 1616 * The Schema Provider configuration delete listener. 1617 * @throws ConfigException 1618 * If the delete listener could not be registered. 1619 */ 1620 void addSchemaProviderDeleteListener(ConfigurationDeleteListener<SchemaProviderCfg> listener) throws ConfigException; 1621 1622 1623 1624 /** 1625 * Deregisters an existing Schema Provider configuration delete listener. 1626 * 1627 * @param listener 1628 * The Schema Provider configuration delete listener. 1629 */ 1630 void removeSchemaProviderDeleteListener(ConfigurationDeleteListener<SchemaProviderCfg> listener); 1631 1632 1633 1634 /** 1635 * Lists the Synchronization Providers. 1636 * 1637 * @return Returns an array containing the names of the 1638 * Synchronization Providers. 1639 */ 1640 String[] listSynchronizationProviders(); 1641 1642 1643 1644 /** 1645 * Gets the named Synchronization Provider. 1646 * 1647 * @param name 1648 * The name of the Synchronization Provider to retrieve. 1649 * @return Returns the named Synchronization Provider. 1650 * @throws ConfigException 1651 * If the Synchronization Provider could not be found or it 1652 * could not be successfully decoded. 1653 */ 1654 SynchronizationProviderCfg getSynchronizationProvider(String name) throws ConfigException; 1655 1656 1657 1658 /** 1659 * Registers to be notified when new Synchronization Providers are added. 1660 * 1661 * @param listener 1662 * The Synchronization Provider configuration add listener. 1663 * @throws ConfigException 1664 * If the add listener could not be registered. 1665 */ 1666 void addSynchronizationProviderAddListener(ConfigurationAddListener<SynchronizationProviderCfg> listener) throws ConfigException; 1667 1668 1669 1670 /** 1671 * Deregisters an existing Synchronization Provider configuration add listener. 1672 * 1673 * @param listener 1674 * The Synchronization Provider configuration add listener. 1675 */ 1676 void removeSynchronizationProviderAddListener(ConfigurationAddListener<SynchronizationProviderCfg> listener); 1677 1678 1679 1680 /** 1681 * Registers to be notified when existing Synchronization Providers are deleted. 1682 * 1683 * @param listener 1684 * The Synchronization Provider configuration delete listener. 1685 * @throws ConfigException 1686 * If the delete listener could not be registered. 1687 */ 1688 void addSynchronizationProviderDeleteListener(ConfigurationDeleteListener<SynchronizationProviderCfg> listener) throws ConfigException; 1689 1690 1691 1692 /** 1693 * Deregisters an existing Synchronization Provider configuration delete listener. 1694 * 1695 * @param listener 1696 * The Synchronization Provider configuration delete listener. 1697 */ 1698 void removeSynchronizationProviderDeleteListener(ConfigurationDeleteListener<SynchronizationProviderCfg> listener); 1699 1700 1701 1702 /** 1703 * Lists the Trust Manager Providers. 1704 * 1705 * @return Returns an array containing the names of the 1706 * Trust Manager Providers. 1707 */ 1708 String[] listTrustManagerProviders(); 1709 1710 1711 1712 /** 1713 * Gets the named Trust Manager Provider. 1714 * 1715 * @param name 1716 * The name of the Trust Manager Provider to retrieve. 1717 * @return Returns the named Trust Manager Provider. 1718 * @throws ConfigException 1719 * If the Trust Manager Provider could not be found or it 1720 * could not be successfully decoded. 1721 */ 1722 TrustManagerProviderCfg getTrustManagerProvider(String name) throws ConfigException; 1723 1724 1725 1726 /** 1727 * Registers to be notified when new Trust Manager Providers are added. 1728 * 1729 * @param listener 1730 * The Trust Manager Provider configuration add listener. 1731 * @throws ConfigException 1732 * If the add listener could not be registered. 1733 */ 1734 void addTrustManagerProviderAddListener(ConfigurationAddListener<TrustManagerProviderCfg> listener) throws ConfigException; 1735 1736 1737 1738 /** 1739 * Deregisters an existing Trust Manager Provider configuration add listener. 1740 * 1741 * @param listener 1742 * The Trust Manager Provider configuration add listener. 1743 */ 1744 void removeTrustManagerProviderAddListener(ConfigurationAddListener<TrustManagerProviderCfg> listener); 1745 1746 1747 1748 /** 1749 * Registers to be notified when existing Trust Manager Providers are deleted. 1750 * 1751 * @param listener 1752 * The Trust Manager Provider configuration delete listener. 1753 * @throws ConfigException 1754 * If the delete listener could not be registered. 1755 */ 1756 void addTrustManagerProviderDeleteListener(ConfigurationDeleteListener<TrustManagerProviderCfg> listener) throws ConfigException; 1757 1758 1759 1760 /** 1761 * Deregisters an existing Trust Manager Provider configuration delete listener. 1762 * 1763 * @param listener 1764 * The Trust Manager Provider configuration delete listener. 1765 */ 1766 void removeTrustManagerProviderDeleteListener(ConfigurationDeleteListener<TrustManagerProviderCfg> listener); 1767 1768 1769 1770 /** 1771 * Lists the Virtual Attributes. 1772 * 1773 * @return Returns an array containing the names of the 1774 * Virtual Attributes. 1775 */ 1776 String[] listVirtualAttributes(); 1777 1778 1779 1780 /** 1781 * Gets the named Virtual Attribute. 1782 * 1783 * @param name 1784 * The name of the Virtual Attribute to retrieve. 1785 * @return Returns the named Virtual Attribute. 1786 * @throws ConfigException 1787 * If the Virtual Attribute could not be found or it 1788 * could not be successfully decoded. 1789 */ 1790 VirtualAttributeCfg getVirtualAttribute(String name) throws ConfigException; 1791 1792 1793 1794 /** 1795 * Registers to be notified when new Virtual Attributes are added. 1796 * 1797 * @param listener 1798 * The Virtual Attribute configuration add listener. 1799 * @throws ConfigException 1800 * If the add listener could not be registered. 1801 */ 1802 void addVirtualAttributeAddListener(ConfigurationAddListener<VirtualAttributeCfg> listener) throws ConfigException; 1803 1804 1805 1806 /** 1807 * Deregisters an existing Virtual Attribute configuration add listener. 1808 * 1809 * @param listener 1810 * The Virtual Attribute configuration add listener. 1811 */ 1812 void removeVirtualAttributeAddListener(ConfigurationAddListener<VirtualAttributeCfg> listener); 1813 1814 1815 1816 /** 1817 * Registers to be notified when existing Virtual Attributes are deleted. 1818 * 1819 * @param listener 1820 * The Virtual Attribute configuration delete listener. 1821 * @throws ConfigException 1822 * If the delete listener could not be registered. 1823 */ 1824 void addVirtualAttributeDeleteListener(ConfigurationDeleteListener<VirtualAttributeCfg> listener) throws ConfigException; 1825 1826 1827 1828 /** 1829 * Deregisters an existing Virtual Attribute configuration delete listener. 1830 * 1831 * @param listener 1832 * The Virtual Attribute configuration delete listener. 1833 */ 1834 void removeVirtualAttributeDeleteListener(ConfigurationDeleteListener<VirtualAttributeCfg> listener); 1835 1836 1837 1838 /** 1839 * Gets the Work Queue. 1840 * 1841 * @return Returns the Work Queue. 1842 * @throws ConfigException 1843 * If the Work Queue could not be found or it could not 1844 * be successfully decoded. 1845 */ 1846 WorkQueueCfg getWorkQueue() throws ConfigException; 1847 1848}