SchemaManager

All Known Implementing Classes:

DefaultSchemaManager
```
public interface SchemaManager
```
A class used to manage access to the Schemas and Registries. It's associated with a SchemaLoader, in charge of loading the schemas from the disk.

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`RELAXED` Two flags for RELAXED and STRICT, this is RELAXED
`static boolean`	`STRICT` Two flags for RELAXED and STRICT, this is STRICT

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`add(SchemaObject schemaObject)` Registers a new SchemaObject.
`boolean`	`delete(SchemaObject schemaObject)` Unregisters a new SchemaObject.
`boolean`	`disable(Schema... schemas)` Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas, and if the registries is still consistent.
`boolean`	`disable(java.lang.String... schemas)` Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas, and if the registries is still consistent.
`boolean`	`disabledRelaxed(Schema... schemas)` Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas.
`boolean`	`disabledRelaxed(java.lang.String... schemas)` Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas.
`boolean`	`enable(Schema... schemas)` Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas, and if the registries is still consistent.
`boolean`	`enable(java.lang.String... schemas)` Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas, and if the registries is still consistent.
`boolean`	`enableRelaxed(Schema... schemas)` Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas.
`boolean`	`enableRelaxed(java.lang.String... schemas)` Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas.
`AttributeType`	`getAttributeType(java.lang.String oid)` Get an AttributeType in the AttributeType registry.
`AttributeTypeRegistry`	`getAttributeTypeRegistry()` Get an immutable reference on the AttributeType registry
`ComparatorRegistry`	`getComparatorRegistry()` Get an immutable reference on the Comparator registry
`java.util.List<Schema>`	`getDisabled()`
`DitContentRuleRegistry`	`getDITContentRuleRegistry()` Get an immutable reference on the DitContentRule registry
`DitStructureRuleRegistry`	`getDITStructureRuleRegistry()` Get an immutable reference on the DitStructureRule registry
`java.util.List<Schema>`	`getEnabled()`
`java.util.List<java.lang.Throwable>`	`getErrors()`
`OidRegistry`	`getGlobalOidRegistry()` Returns a reference to the global OidRegistry
`LdapSyntaxRegistry`	`getLdapSyntaxRegistry()` Get an immutable reference on the LdapSyntax registry
`Schema`	`getLoadedSchema(java.lang.String schemaName)` Gets a schema that has been loaded into these Registries.
`SchemaLoader`	`getLoader()`
`MatchingRuleRegistry`	`getMatchingRuleRegistry()` Get an immutable reference on the MatchingRule registry
`MatchingRuleUseRegistry`	`getMatchingRuleUseRegistry()` Get an immutable reference on the MatchingRuleUse registry
`NameFormRegistry`	`getNameFormRegistry()` Get an immutable reference on the NameForm registry
`Dn`	`getNamingContext()`
`java.util.Map<java.lang.String,OidNormalizer>`	`getNormalizerMapping()` Get an immutable reference on the Normalizer mapping
`NormalizerRegistry`	`getNormalizerRegistry()` Get an immutable reference on the Normalizer registry
`ObjectClassRegistry`	`getObjectClassRegistry()` Get an immutable reference on the ObjectClass registry
`Registries`	`getRegistries()`
`SyntaxCheckerRegistry`	`getSyntaxCheckerRegistry()` Get an immutable reference on the SyntaxChecker registry
`void`	`initialize()` Initializes the SchemaService
`boolean`	`isDisabled(Schema schema)` Tells if the given Schema is disabled
`boolean`	`isDisabled(java.lang.String schemaName)` Tells if the given Schema is disabled
`boolean`	`isEnabled(Schema schema)` Tells if the given Schema is enabled
`boolean`	`isEnabled(java.lang.String schemaName)` Tells if the given Schema is enabled
`boolean`	`isRelaxed()` Tells if the SchemaManager is permissive or if it must be checked against inconsistencies.
`boolean`	`isSchemaLoaded(java.lang.String schemaName)` Tells if the specific schema is loaded
`boolean`	`isStrict()` Tells if the SchemaManager is strict.
`java.util.Set<java.lang.String>`	`listDependentSchemaNames(java.lang.String schemaName)` Get the list of Schema names which has the given schema name as a dependence
`boolean`	`load(Schema... schemas)` Load some Schemas into the registries.
`boolean`	`load(java.lang.String... schemas)` Load some Schemas into the registries.
`boolean`	`loadAllEnabled()` Load all the enabled schema into the Registries.
`boolean`	`loadAllEnabledRelaxed()` Load all the enabled schema into the Registries.
`boolean`	`loadDisabled(Schema... schemas)` Load Schemas into the Registries, even if they are disabled.
`boolean`	`loadDisabled(java.lang.String... schemas)` Load Schemas into the Registries, even if they are disabled.
`boolean`	`loadRelaxed(Schema... schemas)` Load Schemas into the registries, even if there are some errors in the schemas.
`boolean`	`loadRelaxed(java.lang.String... schemas)` Load Schemas into the registries, even if there are some errors in the schemas.
`boolean`	`loadWithDeps(Schema... schemas)` Load some Schemas into the registries, and loads all of the schemas they depend on.
`boolean`	`loadWithDeps(java.lang.String... schemas)` Load some Schemas into the registries, and loads all of the schemas they depend on.
`boolean`	`loadWithDepsRelaxed(Schema... schemas)` Load some Schemas into the registries, and loads all of the schemas they depend on.
`boolean`	`loadWithDepsRelaxed(java.lang.String... schemas)` Load some Schemas into the registries, and loads all of the schemas they depend on.
`AttributeType`	`lookupAttributeTypeRegistry(java.lang.String oid)` Lookup for an AttributeType in the AttributeType registry
`LdapComparator<?>`	`lookupComparatorRegistry(java.lang.String oid)` Lookup for a Comparator in the Comparator registry
`LdapSyntax`	`lookupLdapSyntaxRegistry(java.lang.String oid)` Lookup for an LdapSyntax in the LdapSyntax registry
`MatchingRule`	`lookupMatchingRuleRegistry(java.lang.String oid)` Lookup for a MatchingRule in the MatchingRule registry
`Normalizer`	`lookupNormalizerRegistry(java.lang.String oid)` Lookup for a Normalizer in the Normalizer registry
`ObjectClass`	`lookupObjectClassRegistry(java.lang.String oid)` Lookup for a ObjectClass in the ObjectClass registry
`SyntaxChecker`	`lookupSyntaxCheckerRegistry(java.lang.String oid)` Lookup for a SyntaxChecker in the SyntaxChecker registry
`void`	`setRegistries(Registries registries)` Associate a new Registries to the SchemaManager
`void`	`setRelaxed()` Set the SchemaManager to a RELAXED mode
`void`	`setSchemaLoader(SchemaLoader schemaLoader)` Associate a Schema loader to this SchemaManager
`void`	`setStrict()` Set the SchemaManager to a STRICT mode
`boolean`	`unload(Schema... schemas)` Unload the given set of Schemas
`boolean`	`unload(java.lang.String... schemas)` Unload the given set of Schemas
`SchemaObject`	`unregisterAttributeType(java.lang.String attributeTypeOid)` Removes the registered attributeType from the attributeTypeRegistry
`SchemaObject`	`unregisterComparator(java.lang.String comparatorOid)` Removes the registered Comparator from the ComparatorRegistry
`SchemaObject`	`unregisterDitControlRule(java.lang.String ditControlRuleOid)` Removes the registered DitControlRule from the DitControlRuleRegistry
`SchemaObject`	`unregisterDitStructureRule(java.lang.String ditStructureRuleOid)` Removes the registered DitStructureRule from the DitStructureRuleRegistry
`SchemaObject`	`unregisterLdapSyntax(java.lang.String ldapSyntaxOid)` Removes the registered LdapSyntax from the LdapSyntaxRegistry
`SchemaObject`	`unregisterMatchingRule(java.lang.String matchingRuleOid)` Removes the registered MatchingRule from the MatchingRuleRegistry
`SchemaObject`	`unregisterMatchingRuleUse(java.lang.String matchingRuleUseOid)` Removes the registered MatchingRuleUse from the MatchingRuleUseRegistry
`SchemaObject`	`unregisterNameForm(java.lang.String nameFormOid)` Removes the registered NameForm from the NameFormRegistry
`SchemaObject`	`unregisterNormalizer(java.lang.String normalizerOid)` Removes the registered Normalizer from the NormalizerRegistry
`SchemaObject`	`unregisterObjectClass(java.lang.String objectClassOid)` Removes the registered ObjectClass from the ObjectClassRegistry
`SchemaObject`	`unregisterSyntaxChecker(java.lang.String syntaxCheckerOid)` Removes the registered SyntaxChecker from the SyntaxCheckerRegistry
`boolean`	`verify(Schema... schemas)` Check that the Schemas are consistent regarding the current Registries.
`boolean`	`verify(java.lang.String... schemas)` Check that the Schemas are consistent regarding the current Registries.

- Field Detail
  - STRICT
```
static final boolean STRICT
```
    Two flags for RELAXED and STRICT, this is STRICT
    
    See Also:
    
    Constant Field Values
  - RELAXED
```
static final boolean RELAXED
```
    Two flags for RELAXED and STRICT, this is RELAXED
    
    See Also:
    
    Constant Field Values
- Method Detail
  - load
```
boolean load(Schema... schemas)
      throws LdapException
```
    Load some Schemas into the registries. The Registries is checked after the schemas have been loaded, and if there is an error, the method returns false and the registries is kept intact.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas to load
    
    Returns:
    
    true if the schemas have been loaded and the registries is consistent
    
    Throws:
    
    java.lang.Exception - @TODO
    
    LdapException
  - load
```
boolean load(java.lang.String... schemas)
      throws java.lang.Exception
```
    Load some Schemas into the registries. The Registries is checked after the schemas have been loaded, and if there is an error, the method returns false and the registries is kept intact.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas' name to load
    
    Returns:
    
    true if the schemas have been loaded and the registries is consistent
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadWithDeps
```
boolean loadWithDeps(Schema... schemas)
              throws java.lang.Exception
```
    Load some Schemas into the registries, and loads all of the schemas they depend on. The Registries is checked after the schemas have been loaded, and if there is an error, the method returns false and the registries is kept intact.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas to load
    
    Returns:
    
    true if the schemas have been loaded and the registries is consistent
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadWithDeps
```
boolean loadWithDeps(java.lang.String... schemas)
              throws java.lang.Exception
```
    Load some Schemas into the registries, and loads all of the schemas they depend on. The Registries is checked after the schemas have been loaded, and if there is an error, the method returns false and the registries is kept intact.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas' name to load
    
    Returns:
    
    true if the schemas have been loaded and the registries is consistent
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadRelaxed
```
boolean loadRelaxed(Schema... schemas)
             throws java.lang.Exception
```
    Load Schemas into the registries, even if there are some errors in the schemas. The Registries is checked after the schemas have been loaded. Even if we have errors, the registries will be updated.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas to load, if enabled
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadRelaxed
```
boolean loadRelaxed(java.lang.String... schemas)
             throws java.lang.Exception
```
    Load Schemas into the registries, even if there are some errors in the schemas. The Registries is checked after the schemas have been loaded. Even if we have errors, the registries will be updated.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas' name to load, if enabled
    
    Returns:
    
    true if the schemas have been loaded and the registries is consistent
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadWithDepsRelaxed
```
boolean loadWithDepsRelaxed(Schema... schemas)
                     throws java.lang.Exception
```
    Load some Schemas into the registries, and loads all of the schemas they depend on. The Registries is checked after the schemas have been loaded. Even if we have errors, the registries will be updated.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas to load
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadWithDepsRelaxed
```
boolean loadWithDepsRelaxed(java.lang.String... schemas)
                     throws java.lang.Exception
```
    Load some Schemas into the registries, and loads all of the schemas they depend on. The Registries is checked after the schemas have been loaded. Even if we have errors, the registries will be updated.
    The Schemas must be enabled, and only enabled SchemaObject will be loaded.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - the Schemas' name to load
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadDisabled
```
boolean loadDisabled(Schema... schemas)
              throws java.lang.Exception
```
    Load Schemas into the Registries, even if they are disabled. The disabled SchemaObject from an enabled schema will also be loaded. The Registries will be checked after the schemas have been loaded. Even if we have errors, the Registries will be updated.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - The Schemas to load
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadDisabled
```
boolean loadDisabled(java.lang.String... schemas)
              throws LdapException
```
    Load Schemas into the Registries, even if they are disabled. The disabled SchemaObject from an enabled schema will also be loaded. The Registries will be checked after the schemas have been loaded. Even if we have errors, the Registries will be updated.
    If any error was met, the getErrors() method will contain them
    
    Parameters:
    
    schemas - The Schemas' name to load
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
    
    LdapException
  - loadAllEnabled
```
boolean loadAllEnabled()
                throws java.lang.Exception
```
    Load all the enabled schema into the Registries. The Registries is strict, any inconsistent schema will be rejected.
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - loadAllEnabledRelaxed
```
boolean loadAllEnabledRelaxed()
                       throws java.lang.Exception
```
    Load all the enabled schema into the Registries. The Registries is relaxed, even inconsistent schema will be loaded.
    
    Returns:
    
    true if the schemas have been loaded
    
    Throws:
    
    java.lang.Exception - @TODO
  - unload
```
boolean unload(Schema... schemas)
        throws java.lang.Exception
```
    Unload the given set of Schemas
    
    Parameters:
    
    schemas - The list of Schema to unload
    
    Returns:
    
    True if all the schemas have been unloaded
    
    Throws:
    
    java.lang.Exception
  - unload
```
boolean unload(java.lang.String... schemas)
        throws LdapException
```
    Unload the given set of Schemas
    
    Parameters:
    
    schemas - The list of Schema to unload
    
    Returns:
    
    True if all the schemas have been unloaded
    
    Throws:
    
    LdapException
  - enable
```
boolean enable(Schema... schemas)
        throws java.lang.Exception
```
    Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas, and if the registries is still consistent. If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schemas to enable
    
    Returns:
    
    true if the Registries is still consistent, false otherwise.
    
    Throws:
    
    If - something went wrong
    
    java.lang.Exception
  - enable
```
boolean enable(java.lang.String... schemas)
        throws LdapException
```
    Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas, and if the registries is still consistent. If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schema name to enable
    
    Returns:
    
    true if the Registries is still consistent, false otherwise.
    
    Throws:
    
    If - something went wrong
    
    LdapException
  - enableRelaxed
```
boolean enableRelaxed(Schema... schemas)
```
    Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas. No check is done, the Registries might become inconsistent after this operation.
    
    Parameters:
    
    schemas - The list of schemas to enable
    
    Returns:
    
    true if all the schemas have been enabled
  - enableRelaxed
```
boolean enableRelaxed(java.lang.String... schemas)
```
    Enables a set of Schemas, and returns true if all the schema have been enabled, with all the dependent schemas. No check is done, the Registries might become inconsistent after this operation.
    
    Parameters:
    
    schemas - The list of schema names to enable
    
    Returns:
    
    true if all the schemas have been enabled
  - getEnabled
```
java.util.List<Schema> getEnabled()
```
    Returns:
    
    the list of all the enabled schema
  - isEnabled
```
boolean isEnabled(java.lang.String schemaName)
```
    Tells if the given Schema is enabled
    
    Parameters:
    
    schemaName - The schema name
    
    Returns:
    
    true if the schema is enabled
  - isEnabled
```
boolean isEnabled(Schema schema)
```
    Tells if the given Schema is enabled
    
    Parameters:
    
    schema - The schema
    
    Returns:
    
    true if the schema is enabled
  - disable
```
boolean disable(Schema... schemas)
         throws java.lang.Exception
```
    Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas, and if the registries is still consistent. If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schemas to disable
    
    Returns:
    
    true if the Registries is still consistent, false otherwise.
    
    Throws:
    
    If - something went wrong
    
    java.lang.Exception
  - disable
```
boolean disable(java.lang.String... schemas)
         throws LdapException
```
    Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas, and if the registries is still consistent. If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schema names to disable
    
    Returns:
    
    true if the Registries is still consistent, false otherwise.
    
    Throws:
    
    If - something went wrong
    
    LdapException
  - disabledRelaxed
```
boolean disabledRelaxed(Schema... schemas)
```
    Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas. The Registries is not checked and can be inconsistent after this operation If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schemas to disable
    
    Returns:
    
    true if all the schemas have been disabled
  - disabledRelaxed
```
boolean disabledRelaxed(java.lang.String... schemas)
```
    Disables a set of Schemas, and returns true if all the schema have been disabled, with all the dependent schemas. The Registries is not checked and can be inconsistent after this operation If the modification is ok, the Registries will be updated.
    
    Parameters:
    
    schemas - The list of schema names to disable
    
    Returns:
    
    true if all the schemas have been disabled
  - getDisabled
```
java.util.List<Schema> getDisabled()
```
    Returns:
    
    the list of all the disabled schema
  - isDisabled
```
boolean isDisabled(java.lang.String schemaName)
```
    Tells if the given Schema is disabled
    
    Parameters:
    
    schemaName - The schema name
    
    Returns:
    
    true if the schema is disabled
  - isDisabled
```
boolean isDisabled(Schema schema)
```
    Tells if the given Schema is disabled
    
    Parameters:
    
    schema - The schema
    
    Returns:
    
    true if the schema is disabled
  - isRelaxed
```
boolean isRelaxed()
```
    Tells if the SchemaManager is permissive or if it must be checked against inconsistencies.
    
    Returns:
    
    True if SchemaObjects can be added even if they break the consistency
  - setRelaxed
```
void setRelaxed()
```
    Set the SchemaManager to a RELAXED mode
  - isStrict
```
boolean isStrict()
```
    Tells if the SchemaManager is strict.
    
    Returns:
    
    True if SchemaObjects cannot be added if they break the consistency
  - setStrict
```
void setStrict()
```
    Set the SchemaManager to a STRICT mode
  - verify
```
boolean verify(Schema... schemas)
        throws java.lang.Exception
```
    Check that the Schemas are consistent regarding the current Registries.
    
    Parameters:
    
    schemas - The schemas to check
    
    Returns:
    
    true if the schemas can be loaded in the registries
    
    Throws:
    
    java.lang.Exception - if something went wrong
  - verify
```
boolean verify(java.lang.String... schemas)
        throws java.lang.Exception
```
    Check that the Schemas are consistent regarding the current Registries.
    
    Parameters:
    
    schemas - The schema names to check
    
    Returns:
    
    true if the schemas can be loaded in the registries
    
    Throws:
    
    java.lang.Exception - if something went wrong
  - getRegistries
```
Registries getRegistries()
```
    Returns:
    
    The Registries
  - lookupAttributeTypeRegistry
```
AttributeType lookupAttributeTypeRegistry(java.lang.String oid)
                                   throws LdapException
```
    Lookup for an AttributeType in the AttributeType registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found AttributeType
    
    Throws:
    
    LdapException - if the OID is not found in the AttributeType registry
  - getAttributeType
```
AttributeType getAttributeType(java.lang.String oid)
```
    Get an AttributeType in the AttributeType registry. This method won't throw an exception if the AttributeTyp is not found, it will just return null.
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found AttributeType, or null if not found
  - lookupComparatorRegistry
```
LdapComparator<?> lookupComparatorRegistry(java.lang.String oid)
                                    throws LdapException
```
    Lookup for a Comparator in the Comparator registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found Comparator
    
    Throws:
    
    LdapException - if the OID is not found in the Comparator registry
  - lookupMatchingRuleRegistry
```
MatchingRule lookupMatchingRuleRegistry(java.lang.String oid)
                                 throws LdapException
```
    Lookup for a MatchingRule in the MatchingRule registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found MatchingRule
    
    Throws:
    
    LdapException - if the OID is not found in the MatchingRule registry
  - lookupNormalizerRegistry
```
Normalizer lookupNormalizerRegistry(java.lang.String oid)
                             throws LdapException
```
    Lookup for a Normalizer in the Normalizer registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found Normalizer
    
    Throws:
    
    LdapException - if the OID is not found in the Normalizer registry
  - lookupObjectClassRegistry
```
ObjectClass lookupObjectClassRegistry(java.lang.String oid)
                               throws LdapException
```
    Lookup for a ObjectClass in the ObjectClass registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found ObjectClass
    
    Throws:
    
    LdapException - if the OID is not found in the ObjectClass registry
  - lookupLdapSyntaxRegistry
```
LdapSyntax lookupLdapSyntaxRegistry(java.lang.String oid)
                             throws LdapException
```
    Lookup for an LdapSyntax in the LdapSyntax registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found LdapSyntax
    
    Throws:
    
    LdapException - if the OID is not found in the LdapSyntax registry
  - lookupSyntaxCheckerRegistry
```
SyntaxChecker lookupSyntaxCheckerRegistry(java.lang.String oid)
                                   throws LdapException
```
    Lookup for a SyntaxChecker in the SyntaxChecker registry
    
    Parameters:
    
    oid - the OID we are looking for
    
    Returns:
    
    The found SyntaxChecker
    
    Throws:
    
    LdapException - if the OID is not found in the SyntaxChecker registry
  - getAttributeTypeRegistry
```
AttributeTypeRegistry getAttributeTypeRegistry()
```
    Get an immutable reference on the AttributeType registry
    
    Returns:
    
    A reference to the AttributeType registry.
  - getComparatorRegistry
```
ComparatorRegistry getComparatorRegistry()
```
    Get an immutable reference on the Comparator registry
    
    Returns:
    
    A reference to the Comparator registry.
  - getDITContentRuleRegistry
```
DitContentRuleRegistry getDITContentRuleRegistry()
```
    Get an immutable reference on the DitContentRule registry
    
    Returns:
    
    A reference to the DitContentRule registry.
  - getDITStructureRuleRegistry
```
DitStructureRuleRegistry getDITStructureRuleRegistry()
```
    Get an immutable reference on the DitStructureRule registry
    
    Returns:
    
    A reference to the DitStructureRule registry.
  - getMatchingRuleRegistry
```
MatchingRuleRegistry getMatchingRuleRegistry()
```
    Get an immutable reference on the MatchingRule registry
    
    Returns:
    
    A reference to the MatchingRule registry.
  - getMatchingRuleUseRegistry
```
MatchingRuleUseRegistry getMatchingRuleUseRegistry()
```
    Get an immutable reference on the MatchingRuleUse registry
    
    Returns:
    
    A reference to the MatchingRuleUse registry.
  - getNormalizerRegistry
```
NormalizerRegistry getNormalizerRegistry()
```
    Get an immutable reference on the Normalizer registry
    
    Returns:
    
    A reference to the Normalizer registry.
  - getNameFormRegistry
```
NameFormRegistry getNameFormRegistry()
```
    Get an immutable reference on the NameForm registry
    
    Returns:
    
    A reference to the NameForm registry.
  - getObjectClassRegistry
```
ObjectClassRegistry getObjectClassRegistry()
```
    Get an immutable reference on the ObjectClass registry
    
    Returns:
    
    A reference to the ObjectClass registry.
  - getLdapSyntaxRegistry
```
LdapSyntaxRegistry getLdapSyntaxRegistry()
```
    Get an immutable reference on the LdapSyntax registry
    
    Returns:
    
    A reference to the LdapSyntax registry.
  - getSyntaxCheckerRegistry
```
SyntaxCheckerRegistry getSyntaxCheckerRegistry()
```
    Get an immutable reference on the SyntaxChecker registry
    
    Returns:
    
    A reference to the SyntaxChecker registry.
  - getNormalizerMapping
```
java.util.Map<java.lang.String,OidNormalizer> getNormalizerMapping()
```
    Get an immutable reference on the Normalizer mapping
    
    Returns:
    
    A reference to the Normalizer mapping
  - setRegistries
```
void setRegistries(Registries registries)
```
    Associate a new Registries to the SchemaManager
    
    Parameters:
    
    registries - The new Registries
  - getErrors
```
java.util.List<java.lang.Throwable> getErrors()
```
    Returns:
    
    The errors obtained when checking the registries
  - setSchemaLoader
```
void setSchemaLoader(SchemaLoader schemaLoader)
```
    Associate a Schema loader to this SchemaManager
    
    Parameters:
    
    schemaLoader - The schema loader to use
  - getNamingContext
```
Dn getNamingContext()
```
    Returns:
    
    the namingContext
  - initialize
```
void initialize()
         throws java.lang.Exception
```
    Initializes the SchemaService
    
    Throws:
    
    java.lang.Exception - If the initialization fails
  - getLoader
```
SchemaLoader getLoader()
```
    Returns:
    
    The used loader
  - add
```
boolean add(SchemaObject schemaObject)
     throws LdapException
```
    Registers a new SchemaObject. The registries will be updated only if it's consistent after this addition, if the SchemaManager is in Strict mode. If something went wrong during this operation, the SchemaManager.getErrors() will give the list of generated errors.
    
    Parameters:
    
    schemaObject - the SchemaObject to register
    
    Returns:
    
    true if the addition has been made, false if there were some errors
    
    Throws:
    
    LdapException - if the SchemaObject is already registered or the registration operation is not supported
  - delete
```
boolean delete(SchemaObject schemaObject)
        throws LdapException
```
    Unregisters a new SchemaObject. The registries will be updated only if it's consistent after this deletion, if the SchemaManager is in Strict mode. If something went wrong during this operation, the SchemaManager.getErrors() will give the list of generated errors.
    
    Parameters:
    
    schemaObject - the SchemaObject to unregister
    
    Returns:
    
    true if the deletion has been made, false if there were some errors
    
    Throws:
    
    java.lang.Exception - if the SchemaObject is not registered or the deletion operation is not supported
    
    LdapException
  - unregisterAttributeType
```
SchemaObject unregisterAttributeType(java.lang.String attributeTypeOid)
                              throws LdapException
```
    Removes the registered attributeType from the attributeTypeRegistry
    
    Parameters:
    
    attributeTypeOid - the attributeType OID to unregister
    
    Throws:
    
    LdapException - if the attributeType is invalid
  - unregisterComparator
```
SchemaObject unregisterComparator(java.lang.String comparatorOid)
                           throws LdapException
```
    Removes the registered Comparator from the ComparatorRegistry
    
    Parameters:
    
    comparatorOid - the Comparator OID to unregister
    
    Throws:
    
    LdapException - if the Comparator is invalid
  - unregisterDitControlRule
```
SchemaObject unregisterDitControlRule(java.lang.String ditControlRuleOid)
                               throws LdapException
```
    Removes the registered DitControlRule from the DitControlRuleRegistry
    
    Parameters:
    
    ditControlRuleOid - the DitControlRule OID to unregister
    
    Throws:
    
    LdapException - if the DitControlRule is invalid
  - unregisterDitStructureRule
```
SchemaObject unregisterDitStructureRule(java.lang.String ditStructureRuleOid)
                                 throws LdapException
```
    Removes the registered DitStructureRule from the DitStructureRuleRegistry
    
    Parameters:
    
    ditStructureRuleOid - the DitStructureRule OID to unregister
    
    Throws:
    
    LdapException - if the DitStructureRule is invalid
  - unregisterMatchingRule
```
SchemaObject unregisterMatchingRule(java.lang.String matchingRuleOid)
                             throws LdapException
```
    Removes the registered MatchingRule from the MatchingRuleRegistry
    
    Parameters:
    
    matchingRuleOid - the MatchingRuleRule OID to unregister
    
    Throws:
    
    LdapException - if the MatchingRule is invalid
  - unregisterMatchingRuleUse
```
SchemaObject unregisterMatchingRuleUse(java.lang.String matchingRuleUseOid)
                                throws LdapException
```
    Removes the registered MatchingRuleUse from the MatchingRuleUseRegistry
    
    Parameters:
    
    matchingRuleUseOid - the MatchingRuleUse OID to unregister
    
    Throws:
    
    LdapException - if the MatchingRuleUse is invalid
  - unregisterNameForm
```
SchemaObject unregisterNameForm(java.lang.String nameFormOid)
                         throws LdapException
```
    Removes the registered NameForm from the NameFormRegistry
    
    Parameters:
    
    nameFormOid - the NameForm OID to unregister
    
    Throws:
    
    LdapException - if the NameForm is invalid
  - unregisterNormalizer
```
SchemaObject unregisterNormalizer(java.lang.String normalizerOid)
                           throws LdapException
```
    Removes the registered Normalizer from the NormalizerRegistry
    
    Parameters:
    
    normalizerOid - the Normalizer OID to unregister
    
    Throws:
    
    LdapException - if the Normalizer is invalid
  - unregisterObjectClass
```
SchemaObject unregisterObjectClass(java.lang.String objectClassOid)
                            throws LdapException
```
    Removes the registered ObjectClass from the ObjectClassRegistry
    
    Parameters:
    
    objectClassOid - the ObjectClass OID to unregister
    
    Throws:
    
    LdapException - if the ObjectClass is invalid
  - unregisterLdapSyntax
```
SchemaObject unregisterLdapSyntax(java.lang.String ldapSyntaxOid)
                           throws LdapException
```
    Removes the registered LdapSyntax from the LdapSyntaxRegistry
    
    Parameters:
    
    ldapSyntaxOid - the LdapSyntax OID to unregister
    
    Throws:
    
    LdapException - if the LdapSyntax is invalid
  - unregisterSyntaxChecker
```
SchemaObject unregisterSyntaxChecker(java.lang.String syntaxCheckerOid)
                              throws LdapException
```
    Removes the registered SyntaxChecker from the SyntaxCheckerRegistry
    
    Parameters:
    
    syntaxCheckerOid - the SyntaxChecker OID to unregister
    
    Throws:
    
    LdapException - if the SyntaxChecker is invalid
  - getGlobalOidRegistry
```
OidRegistry getGlobalOidRegistry()
```
    Returns a reference to the global OidRegistry
    
    Returns:
    
    The the global OidRegistry
  - getLoadedSchema
```
Schema getLoadedSchema(java.lang.String schemaName)
```
    Gets a schema that has been loaded into these Registries.
    
    Parameters:
    
    schemaName - the name of the schema to lookup
    
    Returns:
    
    the loaded Schema if one corresponding to the name exists
  - isSchemaLoaded
```
boolean isSchemaLoaded(java.lang.String schemaName)
```
    Tells if the specific schema is loaded
    
    Parameters:
    
    schemaName - The schema we want to check
    
    Returns:
    
    true if the schema is laoded
  - listDependentSchemaNames
```
java.util.Set<java.lang.String> listDependentSchemaNames(java.lang.String schemaName)
```
    Get the list of Schema names which has the given schema name as a dependence
    
    Parameters:
    
    schemaName - The Schema name for which we want to get the list of dependent schemas
    
    Returns:
    
    The list of dependent schemas

Interface SchemaManager

Field Summary

Method Summary

Field Detail

STRICT

RELAXED

Method Detail

load

load

loadWithDeps

loadWithDeps

loadRelaxed

loadRelaxed

loadWithDepsRelaxed

loadWithDepsRelaxed

loadDisabled

loadDisabled

loadAllEnabled

loadAllEnabledRelaxed

unload

unload

enable

enable

enableRelaxed

enableRelaxed

getEnabled

isEnabled

isEnabled

disable

disable

disabledRelaxed

disabledRelaxed

getDisabled

isDisabled

isDisabled

isRelaxed

setRelaxed

isStrict

setStrict

verify

verify

getRegistries

lookupAttributeTypeRegistry

getAttributeType

lookupComparatorRegistry

lookupMatchingRuleRegistry

lookupNormalizerRegistry

lookupObjectClassRegistry

lookupLdapSyntaxRegistry

lookupSyntaxCheckerRegistry

getAttributeTypeRegistry

getComparatorRegistry

getDITContentRuleRegistry

getDITStructureRuleRegistry

getMatchingRuleRegistry

getMatchingRuleUseRegistry

getNormalizerRegistry

getNameFormRegistry

getObjectClassRegistry

getLdapSyntaxRegistry

getSyntaxCheckerRegistry

getNormalizerMapping

setRegistries

getErrors

setSchemaLoader

getNamingContext

initialize

getLoader

add

delete

unregisterAttributeType

unregisterComparator

unregisterDitControlRule

unregisterDitStructureRule

unregisterMatchingRule

unregisterMatchingRuleUse

unregisterNameForm

unregisterNormalizer

unregisterObjectClass

unregisterLdapSyntax