View Javadoc
1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
18   *  
19   */
20  package org.apache.directory.api.ldap.model.schema;
21  
22  
23  import java.util.List;
24  import java.util.Map;
25  import java.util.Set;
26  
27  import org.apache.directory.api.ldap.model.exception.LdapException;
28  import org.apache.directory.api.ldap.model.name.Dn;
29  import org.apache.directory.api.ldap.model.schema.normalizers.OidNormalizer;
30  import org.apache.directory.api.ldap.model.schema.registries.AttributeTypeRegistry;
31  import org.apache.directory.api.ldap.model.schema.registries.ComparatorRegistry;
32  import org.apache.directory.api.ldap.model.schema.registries.DitContentRuleRegistry;
33  import org.apache.directory.api.ldap.model.schema.registries.DitStructureRuleRegistry;
34  import org.apache.directory.api.ldap.model.schema.registries.LdapSyntaxRegistry;
35  import org.apache.directory.api.ldap.model.schema.registries.MatchingRuleRegistry;
36  import org.apache.directory.api.ldap.model.schema.registries.MatchingRuleUseRegistry;
37  import org.apache.directory.api.ldap.model.schema.registries.NameFormRegistry;
38  import org.apache.directory.api.ldap.model.schema.registries.NormalizerRegistry;
39  import org.apache.directory.api.ldap.model.schema.registries.ObjectClassRegistry;
40  import org.apache.directory.api.ldap.model.schema.registries.OidRegistry;
41  import org.apache.directory.api.ldap.model.schema.registries.Registries;
42  import org.apache.directory.api.ldap.model.schema.registries.Schema;
43  import org.apache.directory.api.ldap.model.schema.registries.SchemaLoader;
44  import org.apache.directory.api.ldap.model.schema.registries.SyntaxCheckerRegistry;
45  
46  
47  /**
48   * A class used to manage access to the Schemas and Registries. It's associated 
49   * with a SchemaLoader, in charge of loading the schemas from the disk.
50   * 
51   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
52   */
53  public interface SchemaManager
54  {
55      //---------------------------------------------------------------------------------
56      // Schema loading methods
57      //---------------------------------------------------------------------------------
58      /**
59       * Load some Schemas into the registries. The Registries is checked after the 
60       * schemas have been loaded, and if there is an error, the method returns false
61       * and the registries is kept intact.
62       * <br>
63       * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
64       * <br>
65       * If any error was met, the {@link #getErrors} method will contain them
66       * 
67       * @param schemas the Schemas to load
68       * @return true if the schemas have been loaded and the registries is consistent
69       * @throws Exception @TODO 
70       */
71      boolean load( Schema... schemas ) throws LdapException;
72  
73  
74      /**
75       * Load some Schemas into the registries. The Registries is checked after the 
76       * schemas have been loaded, and if there is an error, the method returns false
77       * and the registries is kept intact.
78       * <br>
79       * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
80       * <br>
81       * If any error was met, the {@link #getErrors} method will contain them
82       * 
83       * @param schemas the Schemas' name to load
84       * @return true if the schemas have been loaded and the registries is consistent
85       * @throws Exception @TODO 
86       */
87      boolean load( String... schemas ) throws Exception;
88  
89  
90      /**
91       * Load some Schemas into the registries, and loads all of the schemas they depend
92       * on. The Registries is checked after the schemas have been loaded, and if there 
93       * is an error, the method returns false and the registries is kept intact.
94       * <br>
95       * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
96       * <br>
97       * If any error was met, the {@link #getErrors} method will contain them
98       * 
99       * @param schemas the Schemas to load
100      * @return true if the schemas have been loaded and the registries is consistent
101      * @throws Exception @TODO 
102      */
103     boolean loadWithDeps( Schema... schemas ) throws Exception;
104 
105 
106     /**
107      * Load some Schemas into the registries, and loads all of the schemas they depend
108      * on. The Registries is checked after the schemas have been loaded, and if there 
109      * is an error, the method returns false and the registries is kept intact.
110      * <br>
111      * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
112      * <br>
113      * If any error was met, the {@link #getErrors} method will contain them
114      * 
115      * @param schemas the Schemas' name to load
116      * @return true if the schemas have been loaded and the registries is consistent
117      * @throws Exception @TODO 
118      */
119     boolean loadWithDeps( String... schemas ) throws Exception;
120 
121 
122     /**
123      * Load Schemas into the registries, even if there are some errors in the schemas. 
124      * The Registries is checked after the schemas have been loaded. Even if we have 
125      * errors, the registries will be updated.
126      * <br>
127      * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
128      * <br>
129      * If any error was met, the {@link #getErrors} method will contain them
130      * 
131      * @param schemas the Schemas to load, if enabled
132      * @return true if the schemas have been loaded
133      * @throws Exception @TODO 
134      */
135     boolean loadRelaxed( Schema... schemas ) throws Exception;
136 
137 
138     /**
139      * Load Schemas into the registries, even if there are some errors in the schemas. 
140      * The Registries is checked after the schemas have been loaded. Even if we have 
141      * errors, the registries will be updated.
142      * <br>
143      * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
144      * <br>
145      * If any error was met, the {@link #getErrors} method will contain them
146      * 
147      * @param schemas the Schemas' name to load, if enabled
148      * @return true if the schemas have been loaded and the registries is consistent
149      * @throws Exception @TODO 
150      */
151     boolean loadRelaxed( String... schemas ) throws Exception;
152 
153 
154     /**
155      * Load some Schemas into the registries, and loads all of the schemas they depend
156      * on. The Registries is checked after the schemas have been loaded. Even if we have 
157      * errors, the registries will be updated.
158      * <br>
159      * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
160      * <br>
161      * If any error was met, the {@link #getErrors} method will contain them
162      * 
163      * @param schemas the Schemas to load
164      * @return true if the schemas have been loaded
165      * @throws Exception @TODO 
166      */
167     boolean loadWithDepsRelaxed( Schema... schemas ) throws Exception;
168 
169 
170     /**
171      * Load some Schemas into the registries, and loads all of the schemas they depend
172      * on. The Registries is checked after the schemas have been loaded. Even if we have 
173      * errors, the registries will be updated.
174      * <br>
175      * The Schemas must be enabled, and only enabled SchemaObject will be loaded.
176      * <br>
177      * If any error was met, the {@link #getErrors} method will contain them
178      * 
179      * @param schemas the Schemas' name to load
180      * @return true if the schemas have been loaded
181      * @throws Exception @TODO 
182      */
183     boolean loadWithDepsRelaxed( String... schemas ) throws Exception;
184 
185 
186     /**
187      * Load Schemas into the Registries, even if they are disabled. The disabled
188      * SchemaObject from an enabled schema will also be loaded. The Registries will
189      * be checked after the schemas have been loaded. Even if we have errors, the
190      * Registries will be updated.
191      * <br>
192      * If any error was met, the {@link #getErrors} method will contain them
193      *
194      * @param schemas The Schemas to load
195      * @return true if the schemas have been loaded
196      * @throws Exception @TODO 
197      */
198     boolean loadDisabled( Schema... schemas ) throws Exception;
199 
200 
201     /**
202      * Load Schemas into the Registries, even if they are disabled. The disabled
203      * SchemaObject from an enabled schema will also be loaded. The Registries will
204      * be checked after the schemas have been loaded. Even if we have errors, the
205      * Registries will be updated.
206      * <br>
207      * If any error was met, the {@link #getErrors} method will contain them
208      *
209      * @param schemas The Schemas' name to load
210      * @return true if the schemas have been loaded
211      * @throws Exception @TODO 
212      */
213     boolean loadDisabled( String... schemas ) throws LdapException;
214 
215 
216     /**
217      * Load all the enabled schema into the Registries. The Registries is strict,
218      * any inconsistent schema will be rejected. 
219      *
220      * @return true if the schemas have been loaded
221      * @throws Exception @TODO
222      */
223     boolean loadAllEnabled() throws Exception;
224 
225 
226     /**
227      * Load all the enabled schema into the Registries. The Registries is relaxed,
228      * even inconsistent schema will be loaded. 
229      *
230      * @return true if the schemas have been loaded
231      * @throws Exception @TODO
232      */
233     boolean loadAllEnabledRelaxed() throws Exception;
234 
235 
236     /**
237      * Unload the given set of Schemas
238      *
239      * @param schemas The list of Schema to unload
240      * @return True if all the schemas have been unloaded
241      */
242     boolean unload( Schema... schemas ) throws Exception;
243 
244 
245     /**
246      * Unload the given set of Schemas
247      *
248      * @param schemas The list of Schema to unload
249      * @return True if all the schemas have been unloaded
250      */
251     boolean unload( String... schemas ) throws LdapException;
252 
253 
254     //---------------------------------------------------------------------------------
255     // Other Schema methods
256     //---------------------------------------------------------------------------------
257     /**
258      * Enables a set of Schemas, and returns true if all the schema have been
259      * enabled, with all the dependent schemas, and if the registries is 
260      * still consistent.
261      * 
262      * If the modification is ok, the Registries will be updated. 
263      * 
264      *  @param schemas The list of schemas to enable
265      *  @return true if the Registries is still consistent, false otherwise.
266      *  @throws If something went wrong
267      */
268     boolean enable( Schema... schemas ) throws Exception;
269 
270 
271     /**
272      * Enables a set of Schemas, and returns true if all the schema have been
273      * enabled, with all the dependent schemas, and if the registries is 
274      * still consistent.
275      * 
276      * If the modification is ok, the Registries will be updated.
277      *  
278      *  @param schemas The list of schema name to enable
279      *  @return true if the Registries is still consistent, false otherwise.
280      *  @throws If something went wrong
281      */
282     boolean enable( String... schemas ) throws LdapException;
283 
284 
285     /**
286      * Enables a set of Schemas, and returns true if all the schema have been
287      * enabled, with all the dependent schemas. No check is done, the Registries
288      * might become inconsistent after this operation.
289      * 
290      *  @param schemas The list of schemas to enable
291      *  @return true if all the schemas have been enabled
292      */
293     boolean enableRelaxed( Schema... schemas );
294 
295 
296     /**
297      * Enables a set of Schemas, and returns true if all the schema have been
298      * enabled, with all the dependent schemas. No check is done, the Registries
299      * might become inconsistent after this operation.
300      * 
301      *  @param schemas The list of schema names to enable
302      *  @return true if all the schemas have been enabled
303      */
304     boolean enableRelaxed( String... schemas );
305 
306 
307     /**
308      * @return the list of all the enabled schema
309      */
310     List<Schema> getEnabled();
311 
312 
313     /**
314      * Tells if the given Schema is enabled
315      *
316      * @param schemaName The schema name
317      * @return true if the schema is enabled
318      */
319     boolean isEnabled( String schemaName );
320 
321 
322     /**
323      * Tells if the given Schema is enabled
324      *
325      * @param schema The schema
326      * @return true if the schema is enabled
327      */
328     boolean isEnabled( Schema schema );
329 
330 
331     /**
332      * Disables a set of Schemas, and returns true if all the schema have been
333      * disabled, with all the dependent schemas, and if the registries is 
334      * still consistent.
335      * 
336      * If the modification is ok, the Registries will be updated. 
337      * 
338      *  @param schemas The list of schemas to disable
339      *  @return true if the Registries is still consistent, false otherwise.
340      *  @throws If something went wrong
341      */
342     boolean disable( Schema... schemas ) throws Exception;
343 
344 
345     /**
346      * Disables a set of Schemas, and returns true if all the schema have been
347      * disabled, with all the dependent schemas, and if the registries is 
348      * still consistent.
349      * 
350      * If the modification is ok, the Registries will be updated. 
351      * 
352      *  @param schemas The list of schema names to disable
353      *  @return true if the Registries is still consistent, false otherwise.
354      *  @throws If something went wrong
355      */
356     boolean disable( String... schemas ) throws LdapException;
357 
358 
359     /**
360      * Disables a set of Schemas, and returns true if all the schema have been
361      * disabled, with all the dependent schemas. The Registries is not checked
362      * and can be inconsistent after this operation
363      * 
364      * If the modification is ok, the Registries will be updated. 
365      * 
366      *  @param schemas The list of schemas to disable
367      *  @return true if all the schemas have been disabled
368      */
369     boolean disabledRelaxed( Schema... schemas );
370 
371 
372     /**
373      * Disables a set of Schemas, and returns true if all the schema have been
374      * disabled, with all the dependent schemas. The Registries is not checked
375      * and can be inconsistent after this operation
376      * 
377      * If the modification is ok, the Registries will be updated. 
378      * 
379      *  @param schemas The list of schema names to disable
380      *  @return true if all the schemas have been disabled
381      */
382     boolean disabledRelaxed( String... schemas );
383 
384 
385     /**
386      * @return the list of all the disabled schema
387      */
388     List<Schema> getDisabled();
389 
390 
391     /**
392      * Tells if the given Schema is disabled
393      *
394      * @param schemaName The schema name
395      * @return true if the schema is disabled
396      */
397     boolean isDisabled( String schemaName );
398 
399 
400     /**
401      * Tells if the given Schema is disabled
402      *
403      * @param schema The schema
404      * @return true if the schema is disabled
405      */
406     boolean isDisabled( Schema schema );
407 
408 
409     /**
410      * Check that the Schemas are consistent regarding the current Registries.
411      * 
412      * @param schemas The schemas to check
413      * @return true if the schemas can be loaded in the registries
414      * @throws Exception if something went wrong
415      */
416     boolean verify( Schema... schemas ) throws Exception;
417 
418 
419     /**
420      * Check that the Schemas are consistent regarding the current Registries.
421      * 
422      * @param schemas The schema names to check
423      * @return true if the schemas can be loaded in the registries
424      * @throws Exception if something went wrong
425      */
426     boolean verify( String... schemas ) throws Exception;
427 
428 
429     /**
430      * @return The Registries
431      */
432     Registries getRegistries();
433 
434 
435     /**
436      * Lookup for an AttributeType in the AttributeType registry
437      * 
438      * @param oid the OID we are looking for
439      * @return The found AttributeType 
440      * @throws LdapException if the OID is not found in the AttributeType registry
441      */
442     AttributeType lookupAttributeTypeRegistry( String oid ) throws LdapException;
443 
444 
445     /**
446      * Get an AttributeType in the AttributeType registry. This method won't
447      * throw an exception if the AttributeTyp is not found, it will just return
448      * null.
449      * 
450      * @param oid the OID we are looking for
451      * @return The found AttributeType, or null if not found
452      */
453     AttributeType getAttributeType( String oid );
454 
455 
456     /**
457      * Lookup for a Comparator in the Comparator registry
458      * 
459      * @param oid the OID we are looking for
460      * @return The found Comparator 
461      * @throws LdapException if the OID is not found in the Comparator registry
462      */
463     LdapComparator<?> lookupComparatorRegistry( String oid ) throws LdapException;
464 
465 
466     /**
467      * Lookup for a MatchingRule in the MatchingRule registry
468      * 
469      * @param oid the OID we are looking for
470      * @return The found MatchingRule 
471      * @throws LdapException if the OID is not found in the MatchingRule registry
472      */
473     MatchingRule lookupMatchingRuleRegistry( String oid ) throws LdapException;
474 
475 
476     /**
477      * Lookup for a Normalizer in the Normalizer registry
478      * 
479      * @param oid the OID we are looking for
480      * @return The found Normalizer 
481      * @throws LdapException if the OID is not found in the Normalizer registry
482      */
483     Normalizer lookupNormalizerRegistry( String oid ) throws LdapException;
484 
485 
486     /**
487      * Lookup for a ObjectClass in the ObjectClass registry
488      * 
489      * @param oid the OID we are looking for
490      * @return The found ObjectClass 
491      * @throws LdapException if the OID is not found in the ObjectClass registry
492      */
493     ObjectClass lookupObjectClassRegistry( String oid ) throws LdapException;
494 
495 
496     /**
497      * Lookup for an LdapSyntax in the LdapSyntax registry
498      * 
499      * @param oid the OID we are looking for
500      * @return The found LdapSyntax 
501      * @throws LdapException if the OID is not found in the LdapSyntax registry
502      */
503     LdapSyntax lookupLdapSyntaxRegistry( String oid ) throws LdapException;
504 
505 
506     /**
507      * Lookup for a SyntaxChecker in the SyntaxChecker registry
508      * 
509      * @param oid the OID we are looking for
510      * @return The found SyntaxChecker 
511      * @throws LdapException if the OID is not found in the SyntaxChecker registry
512      */
513     SyntaxChecker lookupSyntaxCheckerRegistry( String oid ) throws LdapException;
514 
515 
516     /**
517      * Get an immutable reference on the AttributeType registry
518      * 
519      * @return A reference to the AttributeType registry.
520      */
521     AttributeTypeRegistry getAttributeTypeRegistry();
522 
523 
524     /**
525      * Get an immutable reference on the Comparator registry
526      * 
527      * @return A reference to the Comparator registry.
528      */
529     ComparatorRegistry getComparatorRegistry();
530 
531 
532     /**
533      * Get an immutable reference on the DitContentRule registry
534      * 
535      * @return A reference to the DitContentRule registry.
536      */
537     DitContentRuleRegistry getDITContentRuleRegistry();
538 
539 
540     /**
541      * Get an immutable reference on the DitStructureRule registry
542      * 
543      * @return A reference to the DitStructureRule registry.
544      */
545     DitStructureRuleRegistry getDITStructureRuleRegistry();
546 
547 
548     /**
549      * Get an immutable reference on the MatchingRule registry
550      * 
551      * @return A reference to the MatchingRule registry.
552      */
553     MatchingRuleRegistry getMatchingRuleRegistry();
554 
555 
556     /**
557      * Get an immutable reference on the MatchingRuleUse registry
558      * 
559      * @return A reference to the MatchingRuleUse registry.
560      */
561     MatchingRuleUseRegistry getMatchingRuleUseRegistry();
562 
563 
564     /**
565      * Get an immutable reference on the Normalizer registry
566      * 
567      * @return A reference to the Normalizer registry.
568      */
569     NormalizerRegistry getNormalizerRegistry();
570 
571 
572     /**
573      * Get an immutable reference on the NameForm registry
574      * 
575      * @return A reference to the NameForm registry.
576      */
577     NameFormRegistry getNameFormRegistry();
578 
579 
580     /**
581      * Get an immutable reference on the ObjectClass registry
582      * 
583      * @return A reference to the ObjectClass registry.
584      */
585     ObjectClassRegistry getObjectClassRegistry();
586 
587 
588     /**
589      * Get an immutable reference on the LdapSyntax registry
590      * 
591      * @return A reference to the LdapSyntax registry.
592      */
593     LdapSyntaxRegistry getLdapSyntaxRegistry();
594 
595 
596     /**
597      * Get an immutable reference on the SyntaxChecker registry
598      * 
599      * @return A reference to the SyntaxChecker registry.
600      */
601     SyntaxCheckerRegistry getSyntaxCheckerRegistry();
602 
603 
604     /**
605      * Get an immutable reference on the Normalizer mapping
606      * 
607      * @return A reference to the Normalizer mapping
608      */
609     Map<String, OidNormalizer> getNormalizerMapping();
610 
611 
612     /**
613      * Associate a new Registries to the SchemaManager
614      *
615      * @param registries The new Registries
616      */
617     void setRegistries( Registries registries );
618 
619 
620     /**
621      * @return The errors obtained when checking the registries
622      */
623     List<Throwable> getErrors();
624 
625 
626     /**
627      * Associate a Schema loader to this SchemaManager
628      *
629      * @param schemaLoader The schema loader to use
630      */
631     void setSchemaLoader( SchemaLoader schemaLoader );
632 
633 
634     /**
635      * @return the namingContext
636      */
637     Dn getNamingContext();
638 
639 
640     /**
641      * Initializes the SchemaService
642      *
643      * @throws Exception If the initialization fails
644      */
645     void initialize() throws Exception;
646 
647 
648     /**
649      * @return The used loader
650      */
651     SchemaLoader getLoader();
652 
653 
654     /**
655      * Registers a new SchemaObject. The registries will be updated only if it's
656      * consistent after this addition, if the SchemaManager is in Strict mode.
657      * If something went wrong during this operation, the 
658      * SchemaManager.getErrors() will give the list of generated errors.
659      *
660      * @param schemaObject the SchemaObject to register
661      * @return true if the addition has been made, false if there were some errors
662      * @throws LdapException if the SchemaObject is already registered or
663      * the registration operation is not supported
664      */
665     boolean add( SchemaObject schemaObject ) throws LdapException;
666 
667 
668     /**
669      * Unregisters a new SchemaObject. The registries will be updated only if it's
670      * consistent after this deletion, if the SchemaManager is in Strict mode.
671      * If something went wrong during this operation, the 
672      * SchemaManager.getErrors() will give the list of generated errors.
673      *
674      * @param schemaObject the SchemaObject to unregister
675      * @return true if the deletion has been made, false if there were some errors
676      * @throws Exception if the SchemaObject is not registered or
677      * the deletion operation is not supported
678      */
679     boolean delete( SchemaObject schemaObject ) throws LdapException;
680 
681 
682     /**
683      * Removes the registered attributeType from the attributeTypeRegistry 
684      * 
685      * @param attributeTypeOid the attributeType OID to unregister
686      * @throws LdapException if the attributeType is invalid
687      */
688     SchemaObject unregisterAttributeType( String attributeTypeOid ) throws LdapException;
689 
690 
691     /**
692      * Removes the registered Comparator from the ComparatorRegistry 
693      * 
694      * @param comparatorOid the Comparator OID to unregister
695      * @throws LdapException if the Comparator is invalid
696      */
697     SchemaObject unregisterComparator( String comparatorOid ) throws LdapException;
698 
699 
700     /**
701      * Removes the registered DitControlRule from the DitControlRuleRegistry 
702      * 
703      * @param ditControlRuleOid the DitControlRule OID to unregister
704      * @throws LdapException if the DitControlRule is invalid
705      */
706     SchemaObject unregisterDitControlRule( String ditControlRuleOid ) throws LdapException;
707 
708 
709     /**
710      * Removes the registered DitStructureRule from the DitStructureRuleRegistry 
711      * 
712      * @param ditStructureRuleOid the DitStructureRule OID to unregister
713      * @throws LdapException if the DitStructureRule is invalid
714      */
715     SchemaObject unregisterDitStructureRule( String ditStructureRuleOid ) throws LdapException;
716 
717 
718     /**
719      * Removes the registered MatchingRule from the MatchingRuleRegistry 
720      * 
721      * @param matchingRuleOid the MatchingRuleRule OID to unregister
722      * @throws LdapException if the MatchingRule is invalid
723      */
724     SchemaObject unregisterMatchingRule( String matchingRuleOid ) throws LdapException;
725 
726 
727     /**
728      * Removes the registered MatchingRuleUse from the MatchingRuleUseRegistry 
729      * 
730      * @param matchingRuleUseOid the MatchingRuleUse OID to unregister
731      * @throws LdapException if the MatchingRuleUse is invalid
732      */
733     SchemaObject unregisterMatchingRuleUse( String matchingRuleUseOid ) throws LdapException;
734 
735 
736     /**
737      * Removes the registered NameForm from the NameFormRegistry 
738      * 
739      * @param nameFormOid the NameForm OID to unregister
740      * @throws LdapException if the NameForm is invalid
741      */
742     SchemaObject unregisterNameForm( String nameFormOid ) throws LdapException;
743 
744 
745     /**
746      * Removes the registered Normalizer from the NormalizerRegistry 
747      * 
748      * @param normalizerOid the Normalizer OID to unregister
749      * @throws LdapException if the Normalizer is invalid
750      */
751     SchemaObject unregisterNormalizer( String normalizerOid ) throws LdapException;
752 
753 
754     /**
755      * Removes the registered ObjectClass from the ObjectClassRegistry 
756      * 
757      * @param objectClassOid the ObjectClass OID to unregister
758      * @throws LdapException if the ObjectClass is invalid
759      */
760     SchemaObject unregisterObjectClass( String objectClassOid ) throws LdapException;
761 
762 
763     /**
764      * Removes the registered LdapSyntax from the LdapSyntaxRegistry 
765      * 
766      * @param ldapSyntaxOid the LdapSyntax OID to unregister
767      * @throws LdapException if the LdapSyntax is invalid
768      */
769     SchemaObject unregisterLdapSyntax( String ldapSyntaxOid ) throws LdapException;
770 
771 
772     /**
773      * Removes the registered SyntaxChecker from the SyntaxCheckerRegistry 
774      * 
775      * @param syntaxCheckerOid the SyntaxChecker OID to unregister
776      * @throws LdapException if the SyntaxChecker is invalid
777      */
778     SchemaObject unregisterSyntaxChecker( String syntaxCheckerOid ) throws LdapException;
779 
780 
781     /**
782      * Returns a reference to the global OidRegistry
783      *
784      * @return The the global OidRegistry
785      */
786     @SuppressWarnings("rawtypes")
787     OidRegistry getGlobalOidRegistry();
788 
789 
790     /**
791      * Gets a schema that has been loaded into these Registries.
792      * 
793      * @param schemaName the name of the schema to lookup
794      * @return the loaded Schema if one corresponding to the name exists
795      */
796     Schema getLoadedSchema( String schemaName );
797 
798 
799     /**
800      * Tells if the specific schema is loaded
801      *
802      * @param schemaName The schema we want to check
803      * @return true if the schema is laoded
804      */
805     boolean isSchemaLoaded( String schemaName );
806 
807 
808     /**
809      * Get the list of Schema names which has the given schema name as a dependence
810      *
811      * @param schemaName The Schema name for which we want to get the list of dependent schemas
812      * @return The list of dependent schemas
813      */
814     Set<String> listDependentSchemaNames( String schemaName );
815 }