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