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