/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 */
package org.opends.sdk.schema;



import static com.sun.opends.sdk.messages.Messages.*;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import org.opends.sdk.*;
import org.opends.sdk.requests.Requests;
import org.opends.sdk.requests.SearchRequest;
import org.opends.sdk.responses.Responses;
import org.opends.sdk.responses.Result;
import org.opends.sdk.responses.SearchResultEntry;

import com.sun.opends.sdk.util.FutureResultTransformer;
import com.sun.opends.sdk.util.RecursiveFutureResult;
import com.sun.opends.sdk.util.StaticUtils;



/**
 * This class defines a data structure that holds information about the
 * components of the LDAP schema. It includes the following kinds of
 * elements:
 * <UL>
 * <LI>Attribute type definitions</LI>
 * <LI>Object class definitions</LI>
 * <LI>Attribute syntax definitions</LI>
 * <LI>Matching rule definitions</LI>
 * <LI>Matching rule use definitions</LI>
 * <LI>DIT content rule definitions</LI>
 * <LI>DIT structure rule definitions</LI>
 * <LI>Name form definitions</LI>
 * </UL>
 */
public final class Schema
{
  private static class EmptyImpl implements Impl
  {
    private final SchemaCompatOptions options;



    private EmptyImpl()
    {
      this.options = SchemaCompatOptions.defaultOptions();
    }



    public AttributeType getAttributeType(String name)
    {
      // Construct an placeholder attribute type with the given name,
      // the default matching rule, and the default syntax. The OID of
      // the attribute will be the normalized OID alias with "-oid"
      // appended to the given name.
      final StringBuilder builder = new StringBuilder(name.length() + 4);
      StaticUtils.toLowerCase(name, builder);
      builder.append("-oid");
      final String noid = builder.toString();

      return new AttributeType(noid, Collections.singletonList(name),
          "", Schema.getDefaultMatchingRule(), Schema
              .getDefaultSyntax());
    }



    public Collection<AttributeType> getAttributeTypes()
    {
      return Collections.emptyList();
    }



    public List<AttributeType> getAttributeTypesByName(String name)
    {
      return Collections.emptyList();
    }



    public DITContentRule getDITContentRule(String name)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_DCR_UNKNOWN
          .get(name));
    }



    public Collection<DITContentRule> getDITContentRules()
    {
      return Collections.emptyList();
    }



    public Collection<DITContentRule> getDITContentRulesByName(
        String name)
    {
      return Collections.emptyList();
    }



    public DITStructureRule getDITStructureRule(int ruleID)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_DSR_UNKNOWN
          .get(String.valueOf(ruleID)));
    }



    public Collection<DITStructureRule> getDITStructureRulesByName(
        String name)
    {
      return Collections.emptyList();
    }



    public Collection<DITStructureRule> getDITStructureRulesByNameForm(
        NameForm nameForm)
    {
      return Collections.emptyList();
    }



    public Collection<DITStructureRule> getDITStuctureRules()
    {
      return Collections.emptyList();
    }



    public MatchingRule getMatchingRule(String name)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_MR_UNKNOWN.get(name));
    }



    public Collection<MatchingRule> getMatchingRules()
    {
      return Collections.emptyList();
    }



    public Collection<MatchingRule> getMatchingRulesByName(String name)
    {
      return Collections.emptyList();
    }



    public MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule)
        throws UnknownSchemaElementException
    {
      return getMatchingRuleUse(matchingRule.getOID());
    }



    public MatchingRuleUse getMatchingRuleUse(String name)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_MRU_UNKNOWN
          .get(name));
    }



    public Collection<MatchingRuleUse> getMatchingRuleUses()
    {
      return Collections.emptyList();
    }



    public Collection<MatchingRuleUse> getMatchingRuleUsesByName(
        String name)
    {
      return Collections.emptyList();
    }



    public NameForm getNameForm(String name)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_NAMEFORM_UNKNOWN
          .get(name));
    }



    public Collection<NameForm> getNameFormByObjectClass(
        ObjectClass structuralClass)
    {
      return Collections.emptyList();
    }



    public Collection<NameForm> getNameForms()
    {
      return Collections.emptyList();
    }



    public Collection<NameForm> getNameFormsByName(String name)
    {
      return Collections.emptyList();
    }



    public ObjectClass getObjectClass(String name)
        throws UnknownSchemaElementException
    {
      throw new UnknownSchemaElementException(WARN_OBJECTCLASS_UNKNOWN
          .get(name));
    }



    public Collection<ObjectClass> getObjectClasses()
    {
      return Collections.emptyList();
    }



    public Collection<ObjectClass> getObjectClassesByName(String name)
    {
      return Collections.emptyList();
    }



    public SchemaCompatOptions getSchemaCompatOptions()
    {
      return options;
    }



    /**
     * {@inheritDoc}
     */
    public String getSchemaName()
    {
      return "Empty Schema";
    }



    public Syntax getSyntax(String numericOID)
    {
      // Fake up a syntax substituted by the default syntax.
      return new Syntax(numericOID);
    }



    public Collection<Syntax> getSyntaxes()
    {
      return Collections.emptyList();
    }



    public Collection<LocalizableMessage> getWarnings()
    {
      return Collections.emptyList();
    }



    public boolean hasAttributeType(String name)
    {
      // In theory a non-strict schema always contains the requested
      // attribute type, so we could always return true. However, we
      // should provide a way for callers to differentiate between a
      // real attribute type and a faked up attribute type.
      return false;
    }



    public boolean hasDITContentRule(String name)
    {
      return false;
    }



    public boolean hasDITStructureRule(int ruleID)
    {
      return false;
    }



    public boolean hasMatchingRule(String name)
    {
      return false;
    }



    public boolean hasMatchingRuleUse(String name)
    {
      return false;
    }



    public boolean hasNameForm(String name)
    {
      return false;
    }



    public boolean hasObjectClass(String name)
    {
      return false;
    }



    public boolean hasSyntax(String numericOID)
    {
      return false;
    }



    public boolean isStrict()
    {
      return false;
    }
  }



  private static interface Impl
  {
    AttributeType getAttributeType(String name)
        throws UnknownSchemaElementException;



    Collection<AttributeType> getAttributeTypes();



    List<AttributeType> getAttributeTypesByName(String name);



    DITContentRule getDITContentRule(String name)
        throws UnknownSchemaElementException;



    Collection<DITContentRule> getDITContentRules();



    Collection<DITContentRule> getDITContentRulesByName(String name);



    DITStructureRule getDITStructureRule(int ruleID)
        throws UnknownSchemaElementException;



    Collection<DITStructureRule> getDITStructureRulesByName(String name);



    Collection<DITStructureRule> getDITStructureRulesByNameForm(
        NameForm nameForm);



    Collection<DITStructureRule> getDITStuctureRules();



    MatchingRule getMatchingRule(String name)
        throws UnknownSchemaElementException;



    Collection<MatchingRule> getMatchingRules();



    Collection<MatchingRule> getMatchingRulesByName(String name);



    MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule)
        throws UnknownSchemaElementException;



    MatchingRuleUse getMatchingRuleUse(String name)
        throws UnknownSchemaElementException;



    Collection<MatchingRuleUse> getMatchingRuleUses();



    Collection<MatchingRuleUse> getMatchingRuleUsesByName(String name);



    NameForm getNameForm(String name)
        throws UnknownSchemaElementException;



    Collection<NameForm> getNameFormByObjectClass(
        ObjectClass structuralClass);



    Collection<NameForm> getNameForms();



    Collection<NameForm> getNameFormsByName(String name);



    ObjectClass getObjectClass(String name)
        throws UnknownSchemaElementException;



    Collection<ObjectClass> getObjectClasses();



    Collection<ObjectClass> getObjectClassesByName(String name);



    SchemaCompatOptions getSchemaCompatOptions();



    String getSchemaName();



    Syntax getSyntax(String numericOID)
        throws UnknownSchemaElementException;



    Collection<Syntax> getSyntaxes();



    Collection<LocalizableMessage> getWarnings();



    boolean hasAttributeType(String name);



    boolean hasDITContentRule(String name);



    boolean hasDITStructureRule(int ruleID);



    boolean hasMatchingRule(String name);



    boolean hasMatchingRuleUse(String name);



    boolean hasNameForm(String name);



    boolean hasObjectClass(String name);



    boolean hasSyntax(String numericOID);



    boolean isStrict();
  }



  private static class NonStrictImpl implements Impl
  {
    private final Impl strictImpl;



    private NonStrictImpl(Impl strictImpl)
    {
      this.strictImpl = strictImpl;
    }



    public AttributeType getAttributeType(String name)
        throws UnknownSchemaElementException
    {
      if (!strictImpl.hasAttributeType(name))
      {
        // Construct an placeholder attribute type with the given name,
        // the default matching rule, and the default syntax. The OID of
        // the attribute will be the normalized OID alias with "-oid"
        // appended to the given name.
        final StringBuilder builder = new StringBuilder(
            name.length() + 4);
        StaticUtils.toLowerCase(name, builder);
        builder.append("-oid");
        final String noid = builder.toString();

        return new AttributeType(noid, Collections.singletonList(name),
            "", Schema.getDefaultMatchingRule(), Schema
                .getDefaultSyntax());
      }
      return strictImpl.getAttributeType(name);
    }



    public Collection<AttributeType> getAttributeTypes()
    {
      return strictImpl.getAttributeTypes();
    }



    public List<AttributeType> getAttributeTypesByName(String name)
    {
      return strictImpl.getAttributeTypesByName(name);
    }



    public DITContentRule getDITContentRule(String name)
        throws UnknownSchemaElementException
    {
      return strictImpl.getDITContentRule(name);
    }



    public Collection<DITContentRule> getDITContentRules()
    {
      return strictImpl.getDITContentRules();
    }



    public Collection<DITContentRule> getDITContentRulesByName(
        String name)
    {
      return strictImpl.getDITContentRulesByName(name);
    }



    public DITStructureRule getDITStructureRule(int ruleID)
        throws UnknownSchemaElementException
    {
      return strictImpl.getDITStructureRule(ruleID);
    }



    public Collection<DITStructureRule> getDITStructureRulesByName(
        String name)
    {
      return strictImpl.getDITStructureRulesByName(name);
    }



    public Collection<DITStructureRule> getDITStructureRulesByNameForm(
        NameForm nameForm)
    {
      return strictImpl.getDITStructureRulesByNameForm(nameForm);
    }



    public Collection<DITStructureRule> getDITStuctureRules()
    {
      return strictImpl.getDITStuctureRules();
    }



    public MatchingRule getMatchingRule(String name)
        throws UnknownSchemaElementException
    {
      return strictImpl.getMatchingRule(name);
    }



    public Collection<MatchingRule> getMatchingRules()
    {
      return strictImpl.getMatchingRules();
    }



    public Collection<MatchingRule> getMatchingRulesByName(String name)
    {
      return strictImpl.getMatchingRulesByName(name);
    }



    public MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule)
        throws UnknownSchemaElementException
    {
      return strictImpl.getMatchingRuleUse(matchingRule);
    }



    public MatchingRuleUse getMatchingRuleUse(String name)
        throws UnknownSchemaElementException
    {
      return strictImpl.getMatchingRuleUse(name);
    }



    public Collection<MatchingRuleUse> getMatchingRuleUses()
    {
      return strictImpl.getMatchingRuleUses();
    }



    public Collection<MatchingRuleUse> getMatchingRuleUsesByName(
        String name)
    {
      return strictImpl.getMatchingRuleUsesByName(name);
    }



    public NameForm getNameForm(String name)
        throws UnknownSchemaElementException
    {
      return strictImpl.getNameForm(name);
    }



    public Collection<NameForm> getNameFormByObjectClass(
        ObjectClass structuralClass)
    {
      return strictImpl.getNameFormByObjectClass(structuralClass);
    }



    public Collection<NameForm> getNameForms()
    {
      return strictImpl.getNameForms();
    }



    public Collection<NameForm> getNameFormsByName(String name)
    {
      return strictImpl.getNameFormsByName(name);
    }



    public ObjectClass getObjectClass(String name)
        throws UnknownSchemaElementException
    {
      return strictImpl.getObjectClass(name);
    }



    public Collection<ObjectClass> getObjectClasses()
    {
      return strictImpl.getObjectClasses();
    }



    public Collection<ObjectClass> getObjectClassesByName(String name)
    {
      return strictImpl.getObjectClassesByName(name);
    }



    public SchemaCompatOptions getSchemaCompatOptions()
    {
      return strictImpl.getSchemaCompatOptions();
    }



    public String getSchemaName()
    {
      return strictImpl.getSchemaName();
    }



    public Syntax getSyntax(String numericOID)
    {
      if (!strictImpl.hasSyntax(numericOID))
      {
        return new Syntax(numericOID);
      }
      return strictImpl.getSyntax(numericOID);
    }



    public Collection<Syntax> getSyntaxes()
    {
      return strictImpl.getSyntaxes();
    }



    public Collection<LocalizableMessage> getWarnings()
    {
      return strictImpl.getWarnings();
    }



    public boolean hasAttributeType(String name)
    {
      // In theory a non-strict schema always contains the requested
      // attribute type, so we could always return true. However, we
      // should provide a way for callers to differentiate between a
      // real attribute type and a faked up attribute type.
      return strictImpl.hasAttributeType(name);
    }



    public boolean hasDITContentRule(String name)
    {
      return strictImpl.hasDITContentRule(name);
    }



    public boolean hasDITStructureRule(int ruleID)
    {
      return strictImpl.hasDITStructureRule(ruleID);
    }



    public boolean hasMatchingRule(String name)
    {
      return strictImpl.hasMatchingRule(name);
    }



    public boolean hasMatchingRuleUse(String name)
    {
      return strictImpl.hasMatchingRuleUse(name);
    }



    public boolean hasNameForm(String name)
    {
      return strictImpl.hasNameForm(name);
    }



    public boolean hasObjectClass(String name)
    {
      return strictImpl.hasObjectClass(name);
    }



    public boolean hasSyntax(String numericOID)
    {
      return strictImpl.hasSyntax(numericOID);
    }



    public boolean isStrict()
    {
      return false;
    }
  }



  private static class StrictImpl implements Impl
  {
    private final Map<Integer, DITStructureRule> id2StructureRules;

    private final Map<String, List<AttributeType>> name2AttributeTypes;

    private final Map<String, List<DITContentRule>> name2ContentRules;

    private final Map<String, List<MatchingRule>> name2MatchingRules;

    private final Map<String, List<MatchingRuleUse>> name2MatchingRuleUses;

    private final Map<String, List<NameForm>> name2NameForms;

    private final Map<String, List<ObjectClass>> name2ObjectClasses;

    private final Map<String, List<DITStructureRule>> name2StructureRules;

    private final Map<String, List<DITStructureRule>> nameForm2StructureRules;

    private final Map<String, AttributeType> numericOID2AttributeTypes;

    private final Map<String, DITContentRule> numericOID2ContentRules;

    private final Map<String, MatchingRule> numericOID2MatchingRules;

    private final Map<String, MatchingRuleUse> numericOID2MatchingRuleUses;

    private final Map<String, NameForm> numericOID2NameForms;

    private final Map<String, ObjectClass> numericOID2ObjectClasses;

    private final Map<String, Syntax> numericOID2Syntaxes;

    private final Map<String, List<NameForm>> objectClass2NameForms;

    private final SchemaCompatOptions options;

    private final List<LocalizableMessage> warnings;

    private final String schemaName;



    private StrictImpl(String schemaName,
        Map<String, Syntax> numericOID2Syntaxes,
        Map<String, MatchingRule> numericOID2MatchingRules,
        Map<String, MatchingRuleUse> numericOID2MatchingRuleUses,
        Map<String, AttributeType> numericOID2AttributeTypes,
        Map<String, ObjectClass> numericOID2ObjectClasses,
        Map<String, NameForm> numericOID2NameForms,
        Map<String, DITContentRule> numericOID2ContentRules,
        Map<Integer, DITStructureRule> id2StructureRules,
        Map<String, List<MatchingRule>> name2MatchingRules,
        Map<String, List<MatchingRuleUse>> name2MatchingRuleUses,
        Map<String, List<AttributeType>> name2AttributeTypes,
        Map<String, List<ObjectClass>> name2ObjectClasses,
        Map<String, List<NameForm>> name2NameForms,
        Map<String, List<DITContentRule>> name2ContentRules,
        Map<String, List<DITStructureRule>> name2StructureRules,
        Map<String, List<NameForm>> objectClass2NameForms,
        Map<String, List<DITStructureRule>> nameForm2StructureRules,
        SchemaCompatOptions options, List<LocalizableMessage> warnings)
    {
      this.schemaName = schemaName;
      this.numericOID2Syntaxes = Collections
          .unmodifiableMap(numericOID2Syntaxes);
      this.numericOID2MatchingRules = Collections
          .unmodifiableMap(numericOID2MatchingRules);
      this.numericOID2MatchingRuleUses = Collections
          .unmodifiableMap(numericOID2MatchingRuleUses);
      this.numericOID2AttributeTypes = Collections
          .unmodifiableMap(numericOID2AttributeTypes);
      this.numericOID2ObjectClasses = Collections
          .unmodifiableMap(numericOID2ObjectClasses);
      this.numericOID2NameForms = Collections
          .unmodifiableMap(numericOID2NameForms);
      this.numericOID2ContentRules = Collections
          .unmodifiableMap(numericOID2ContentRules);
      this.id2StructureRules = Collections
          .unmodifiableMap(id2StructureRules);
      this.name2MatchingRules = Collections
          .unmodifiableMap(name2MatchingRules);
      this.name2MatchingRuleUses = Collections
          .unmodifiableMap(name2MatchingRuleUses);
      this.name2AttributeTypes = Collections
          .unmodifiableMap(name2AttributeTypes);
      this.name2ObjectClasses = Collections
          .unmodifiableMap(name2ObjectClasses);
      this.name2NameForms = Collections.unmodifiableMap(name2NameForms);
      this.name2ContentRules = Collections
          .unmodifiableMap(name2ContentRules);
      this.name2StructureRules = Collections
          .unmodifiableMap(name2StructureRules);
      this.objectClass2NameForms = Collections
          .unmodifiableMap(objectClass2NameForms);
      this.nameForm2StructureRules = Collections
          .unmodifiableMap(nameForm2StructureRules);
      this.options = options;
      this.warnings = Collections.unmodifiableList(warnings);
    }



    public AttributeType getAttributeType(String name)
        throws UnknownSchemaElementException
    {
      final AttributeType type = numericOID2AttributeTypes.get(name);
      if (type != null)
      {
        return type;
      }
      final List<AttributeType> attributes = name2AttributeTypes
          .get(StaticUtils.toLowerCase(name));
      if (attributes != null)
      {
        if (attributes.size() == 1)
        {
          return attributes.get(0);
        }
        throw new UnknownSchemaElementException(
            WARN_ATTR_TYPE_AMBIGIOUS.get(name));
      }
      throw new UnknownSchemaElementException(WARN_ATTR_TYPE_UNKNOWN
          .get(name));
    }



    public Collection<AttributeType> getAttributeTypes()
    {
      return numericOID2AttributeTypes.values();
    }



    public List<AttributeType> getAttributeTypesByName(String name)
    {
      final List<AttributeType> attributes = name2AttributeTypes
          .get(StaticUtils.toLowerCase(name));
      if (attributes == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return attributes;
      }
    }



    public DITContentRule getDITContentRule(String name)
        throws UnknownSchemaElementException
    {
      final DITContentRule rule = numericOID2ContentRules.get(name);
      if (rule != null)
      {
        return rule;
      }
      final List<DITContentRule> rules = name2ContentRules
          .get(StaticUtils.toLowerCase(name));
      if (rules != null)
      {
        if (rules.size() == 1)
        {
          return rules.get(0);
        }
        throw new UnknownSchemaElementException(WARN_DCR_AMBIGIOUS
            .get(name));
      }
      throw new UnknownSchemaElementException(WARN_DCR_UNKNOWN
          .get(name));
    }



    public Collection<DITContentRule> getDITContentRules()
    {
      return numericOID2ContentRules.values();
    }



    public Collection<DITContentRule> getDITContentRulesByName(
        String name)
    {
      final List<DITContentRule> rules = name2ContentRules
          .get(StaticUtils.toLowerCase(name));
      if (rules == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return rules;
      }
    }



    public DITStructureRule getDITStructureRule(int ruleID)
        throws UnknownSchemaElementException
    {
      final DITStructureRule rule = id2StructureRules.get(ruleID);
      if (rule == null)
      {
        throw new UnknownSchemaElementException(WARN_DSR_UNKNOWN
            .get(String.valueOf(ruleID)));
      }
      return rule;
    }



    public Collection<DITStructureRule> getDITStructureRulesByName(
        String name)
    {
      final List<DITStructureRule> rules = name2StructureRules
          .get(StaticUtils.toLowerCase(name));
      if (rules == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return rules;
      }
    }



    public Collection<DITStructureRule> getDITStructureRulesByNameForm(
        NameForm nameForm)
    {
      final List<DITStructureRule> rules = nameForm2StructureRules
          .get(nameForm.getOID());
      if (rules == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return rules;
      }
    }



    public Collection<DITStructureRule> getDITStuctureRules()
    {
      return id2StructureRules.values();
    }



    public MatchingRule getMatchingRule(String name)
        throws UnknownSchemaElementException
    {
      final MatchingRule rule = numericOID2MatchingRules.get(name);
      if (rule != null)
      {
        return rule;
      }
      final List<MatchingRule> rules = name2MatchingRules
          .get(StaticUtils.toLowerCase(name));
      if (rules != null)
      {
        if (rules.size() == 1)
        {
          return rules.get(0);
        }
        throw new UnknownSchemaElementException(WARN_MR_AMBIGIOUS
            .get(name));
      }
      throw new UnknownSchemaElementException(WARN_MR_UNKNOWN.get(name));
    }



    public Collection<MatchingRule> getMatchingRules()
    {
      return numericOID2MatchingRules.values();
    }



    public Collection<MatchingRule> getMatchingRulesByName(String name)
    {
      final List<MatchingRule> rules = name2MatchingRules
          .get(StaticUtils.toLowerCase(name));
      if (rules == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return rules;
      }
    }



    public MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule)
        throws UnknownSchemaElementException
    {
      return getMatchingRuleUse(matchingRule.getOID());
    }



    public MatchingRuleUse getMatchingRuleUse(String name)
        throws UnknownSchemaElementException
    {
      final MatchingRuleUse rule = numericOID2MatchingRuleUses
          .get(name);
      if (rule != null)
      {
        return rule;
      }
      final List<MatchingRuleUse> uses = name2MatchingRuleUses
          .get(StaticUtils.toLowerCase(name));
      if (uses != null)
      {
        if (uses.size() == 1)
        {
          return uses.get(0);
        }
        throw new UnknownSchemaElementException(WARN_MRU_AMBIGIOUS
            .get(name));
      }
      throw new UnknownSchemaElementException(WARN_MRU_UNKNOWN
          .get(name));
    }



    public Collection<MatchingRuleUse> getMatchingRuleUses()
    {
      return numericOID2MatchingRuleUses.values();
    }



    public Collection<MatchingRuleUse> getMatchingRuleUsesByName(
        String name)
    {
      final List<MatchingRuleUse> rules = name2MatchingRuleUses
          .get(StaticUtils.toLowerCase(name));
      if (rules == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return rules;
      }
    }



    public NameForm getNameForm(String name)
        throws UnknownSchemaElementException
    {
      final NameForm form = numericOID2NameForms.get(name);
      if (form != null)
      {
        return form;
      }
      final List<NameForm> forms = name2NameForms.get(StaticUtils
          .toLowerCase(name));
      if (forms != null)
      {
        if (forms.size() == 1)
        {
          return forms.get(0);
        }
        throw new UnknownSchemaElementException(WARN_NAMEFORM_AMBIGIOUS
            .get(name));
      }
      throw new UnknownSchemaElementException(WARN_NAMEFORM_UNKNOWN
          .get(name));
    }



    public Collection<NameForm> getNameFormByObjectClass(
        ObjectClass structuralClass)
    {
      final List<NameForm> forms = objectClass2NameForms
          .get(structuralClass.getOID());
      if (forms == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return forms;
      }
    }



    public Collection<NameForm> getNameForms()
    {
      return numericOID2NameForms.values();
    }



    public Collection<NameForm> getNameFormsByName(String name)
    {
      final List<NameForm> forms = name2NameForms.get(StaticUtils
          .toLowerCase(name));
      if (forms == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return forms;
      }
    }



    public ObjectClass getObjectClass(String name)
        throws UnknownSchemaElementException
    {
      final ObjectClass oc = numericOID2ObjectClasses.get(name);
      if (oc != null)
      {
        return oc;
      }
      final List<ObjectClass> classes = name2ObjectClasses
          .get(StaticUtils.toLowerCase(name));
      if (classes != null)
      {
        if (classes.size() == 1)
        {
          return classes.get(0);
        }
        throw new UnknownSchemaElementException(
            WARN_OBJECTCLASS_AMBIGIOUS.get(name));
      }
      throw new UnknownSchemaElementException(WARN_OBJECTCLASS_UNKNOWN
          .get(name));
    }



    public Collection<ObjectClass> getObjectClasses()
    {
      return numericOID2ObjectClasses.values();
    }



    public Collection<ObjectClass> getObjectClassesByName(String name)
    {
      final List<ObjectClass> classes = name2ObjectClasses
          .get(StaticUtils.toLowerCase(name));
      if (classes == null)
      {
        return Collections.emptyList();
      }
      else
      {
        return classes;
      }
    }



    public SchemaCompatOptions getSchemaCompatOptions()
    {
      return options;
    }



    public String getSchemaName()
    {
      return schemaName;
    }



    public Syntax getSyntax(String numericOID)
        throws UnknownSchemaElementException
    {
      final Syntax syntax = numericOID2Syntaxes.get(numericOID);
      if (syntax == null)
      {
        throw new UnknownSchemaElementException(WARN_SYNTAX_UNKNOWN
            .get(numericOID));
      }
      return syntax;
    }



    public Collection<Syntax> getSyntaxes()
    {
      return numericOID2Syntaxes.values();
    }



    public Collection<LocalizableMessage> getWarnings()
    {
      return warnings;
    }



    public boolean hasAttributeType(String name)
    {
      if (numericOID2AttributeTypes.containsKey(name))
      {
        return true;
      }
      final List<AttributeType> attributes = name2AttributeTypes
          .get(StaticUtils.toLowerCase(name));
      return attributes != null && attributes.size() == 1;
    }



    public boolean hasDITContentRule(String name)
    {
      if (numericOID2ContentRules.containsKey(name))
      {
        return true;
      }
      final List<DITContentRule> rules = name2ContentRules
          .get(StaticUtils.toLowerCase(name));
      return rules != null && rules.size() == 1;
    }



    public boolean hasDITStructureRule(int ruleID)
    {
      return id2StructureRules.containsKey(ruleID);
    }



    public boolean hasMatchingRule(String name)
    {
      if (numericOID2MatchingRules.containsKey(name))
      {
        return true;
      }
      final List<MatchingRule> rules = name2MatchingRules
          .get(StaticUtils.toLowerCase(name));
      return rules != null && rules.size() == 1;
    }



    public boolean hasMatchingRuleUse(String name)
    {
      if (numericOID2MatchingRuleUses.containsKey(name))
      {
        return true;
      }
      final List<MatchingRuleUse> uses = name2MatchingRuleUses
          .get(StaticUtils.toLowerCase(name));
      return uses != null && uses.size() == 1;
    }



    public boolean hasNameForm(String name)
    {
      if (numericOID2NameForms.containsKey(name))
      {
        return true;
      }
      final List<NameForm> forms = name2NameForms.get(StaticUtils
          .toLowerCase(name));
      return forms != null && forms.size() == 1;
    }



    public boolean hasObjectClass(String name)
    {
      if (numericOID2ObjectClasses.containsKey(name))
      {
        return true;
      }
      final List<ObjectClass> classes = name2ObjectClasses
          .get(StaticUtils.toLowerCase(name));
      return classes != null && classes.size() == 1;
    }



    public boolean hasSyntax(String numericOID)
    {
      return numericOID2Syntaxes.containsKey(numericOID);
    }



    public boolean isStrict()
    {
      return true;
    }
  }



  private static final Schema CORE_SCHEMA = CoreSchemaImpl
      .getInstance();

  private static final Schema EMPTY_SCHEMA = new Schema(new EmptyImpl());

  private static volatile Schema DEFAULT_SCHEMA = CoreSchemaImpl
      .getInstance();

  private static final AttributeDescription ATTR_ATTRIBUTE_TYPES = AttributeDescription
      .valueOf("attributeTypes");

  private static final AttributeDescription ATTR_DIT_CONTENT_RULES = AttributeDescription
      .valueOf("dITContentRules");

  private static final AttributeDescription ATTR_DIT_STRUCTURE_RULES = AttributeDescription
      .valueOf("dITStructureRules");

  private static final AttributeDescription ATTR_LDAP_SYNTAXES = AttributeDescription
      .valueOf("ldapSyntaxes");

  private static final AttributeDescription ATTR_MATCHING_RULE_USE = AttributeDescription
      .valueOf("matchingRuleUse");

  private static final AttributeDescription ATTR_MATCHING_RULES = AttributeDescription
      .valueOf("matchingRules");

  private static final AttributeDescription ATTR_NAME_FORMS = AttributeDescription
      .valueOf("nameForms");

  private static final AttributeDescription ATTR_OBJECT_CLASSES = AttributeDescription
      .valueOf("objectClasses");

  private static final AttributeDescription ATTR_SUBSCHEMA_SUBENTRY = AttributeDescription
      .valueOf("subschemaSubentry");

  private static final String[] SUBSCHEMA_ATTRS = new String[] {
      ATTR_LDAP_SYNTAXES.toString(), ATTR_ATTRIBUTE_TYPES.toString(),
      ATTR_DIT_CONTENT_RULES.toString(),
      ATTR_DIT_STRUCTURE_RULES.toString(),
      ATTR_MATCHING_RULE_USE.toString(),
      ATTR_MATCHING_RULES.toString(), ATTR_NAME_FORMS.toString(),
      ATTR_OBJECT_CLASSES.toString() };

  private static final Filter SUBSCHEMA_FILTER = Filter
      .newEqualityMatchFilter(CoreSchema.getObjectClassAttributeType()
          .getNameOrOID(), CoreSchema.getSubschemaObjectClass()
          .getNameOrOID());

  private static final String[] SUBSCHEMA_SUBENTRY_ATTRS = new String[] { ATTR_SUBSCHEMA_SUBENTRY
      .toString() };



  /**
   * Returns the core schema. The core schema is non-strict and contains
   * the following standard LDAP schema elements:
   * <ul>
   * <li><a href="http://tools.ietf.org/html/rfc4512">RFC 4512 -
   * Lightweight Directory Access Protocol (LDAP): Directory Information
   * Models </a>
   * <li><a href="http://tools.ietf.org/html/rfc4517">RFC 4517 -
   * Lightweight Directory Access Protocol (LDAP): Syntaxes and Matching
   * Rules </a>
   * <li><a href="http://tools.ietf.org/html/rfc4519">RFC 4519 -
   * Lightweight Directory Access Protocol (LDAP): Schema for User
   * Applications </a>
   * <li><a href="http://tools.ietf.org/html/rfc4530">RFC 4530 -
   * Lightweight Directory Access Protocol (LDAP): entryUUID Operational
   * Attribute </a>
   * <li><a href="http://tools.ietf.org/html/rfc3045">RFC 3045 - Storing
   * Vendor Information in the LDAP root DSE </a>
   * <li><a href="http://tools.ietf.org/html/rfc3112">RFC 3112 - LDAP
   * Authentication Password Schema </a>
   * </ul>
   *
   * @return The core schema.
   */
  public static Schema getCoreSchema()
  {
    return CORE_SCHEMA;
  }



  /**
   * Returns the default schema which should be used by this
   * application. The default schema is initially set to the core
   * schema.
   *
   * @return The default schema which should be used by this
   *         application.
   */
  public static Schema getDefaultSchema()
  {
    return DEFAULT_SCHEMA;
  }



  /**
   * Returns the empty schema. The empty schema is non-strict and does
   * not contain any schema elements.
   *
   * @return The empty schema.
   */
  public static Schema getEmptySchema()
  {
    return EMPTY_SCHEMA;
  }



  /**
   * Reads the schema from the Directory Server contained in the named
   * subschema sub-entry.
   * <p>
   * If the requested schema is not returned by the Directory Server
   * then the request will fail with an {@link EntryNotFoundException}.
   * More specifically, the returned future will never return {@code
   * null}.
   * <p>
   * Implementations may choose to perform optimizations such as
   * caching.
   *
   * @param connection
   *          A connection to the Directory Server whose schema is to be
   *          read.
   * @param name
   *          The distinguished name of the subschema sub-entry.
   * @param handler
   *          A result handler which can be used to asynchronously
   *          process the operation result when it is received, may be
   *          {@code null}.
   * @return A future representing the result of the operation.
   * @throws UnsupportedOperationException
   *           If this connection does not support search operations.
   * @throws IllegalStateException
   *           If this connection has already been closed, i.e. if
   *           {@code isClosed() == true}.
   * @throws NullPointerException
   *           If the {@code connection} or {@code name} was {@code
   *           null}.
   */
  public static FutureResult<Schema> readSchema(
      AsynchronousConnection connection, DN name,
      ResultHandler<? super Schema> handler)
      throws UnsupportedOperationException, IllegalStateException,
      NullPointerException
  {
    final SearchRequest request = getReadSchemaSearchRequest(name);

    final FutureResultTransformer<SearchResultEntry, Schema> future = new FutureResultTransformer<SearchResultEntry, Schema>(
        handler)
    {

      protected Schema transformResult(SearchResultEntry result)
          throws ErrorResultException
      {
        return valueOf(result);
      }

    };

    final FutureResult<SearchResultEntry> innerFuture = connection
        .searchSingleEntry(request, future);
    future.setFutureResult(innerFuture);
    return future;
  }



  /**
   * Reads the schema from the Directory Server contained in the named
   * subschema sub-entry using the provided connection.
   * <p>
   * If the requested schema is not returned by the Directory Server
   * then the request will fail with an {@link EntryNotFoundException}.
   * More specifically, this method will never return {@code null}.
   *
   * @param connection
   *          A connection to the Directory Server whose schema is to be
   *          read.
   * @param name
   *          The distinguished name of the subschema sub-entry.
   * @return The schema from the Directory Server.
   * @throws ErrorResultException
   *           If the result code indicates that the request failed for
   *           some reason.
   * @throws InterruptedException
   *           If the current thread was interrupted while waiting.
   * @throws UnsupportedOperationException
   *           If the connection does not support search operations.
   * @throws IllegalStateException
   *           If the connection has already been closed, i.e. if
   *           {@code isClosed() == true}.
   * @throws NullPointerException
   *           If the {@code connection} or {@code name} was {@code
   *           null}.
   */
  public static Schema readSchema(Connection connection, DN name)
      throws ErrorResultException, InterruptedException,
      UnsupportedOperationException, IllegalStateException,
      NullPointerException
  {
    final SearchRequest request = getReadSchemaSearchRequest(name);
    final Entry entry = connection.searchSingleEntry(request);
    return valueOf(entry);
  }



  /**
   * Reads the schema from the Directory Server which applies to the
   * named entry.
   * <p>
   * If the requested entry or its associated schema are not returned by
   * the Directory Server then the request will fail with an
   * {@link EntryNotFoundException}. More specifically, the returned
   * future will never return {@code null}.
   * <p>
   * A typical implementation will first read the {@code
   * subschemaSubentry} attribute of the entry in order to locate the
   * schema. However, implementations may choose to perform other
   * optimizations, such as caching.
   *
   * @param connection
   *          A connection to the Directory Server whose schema is to be
   *          read.
   * @param name
   *          The distinguished name of the entry whose schema is to be
   *          located.
   * @param handler
   *          A result handler which can be used to asynchronously
   *          process the operation result when it is received, may be
   *          {@code null}.
   * @return A future representing the result of the operation.
   * @throws UnsupportedOperationException
   *           If this connection does not support search operations.
   * @throws IllegalStateException
   *           If this connection has already been closed, i.e. if
   *           {@code isClosed() == true}.
   * @throws NullPointerException
   *           If the {@code connection} or {@code name} was {@code
   *           null}.
   */
  public static FutureResult<Schema> readSchemaForEntry(
      final AsynchronousConnection connection, final DN name,
      ResultHandler<Schema> handler)
      throws UnsupportedOperationException, IllegalStateException,
      NullPointerException
  {
    final RecursiveFutureResult<SearchResultEntry, Schema> future = new RecursiveFutureResult<SearchResultEntry, Schema>(
        handler)
    {

      protected FutureResult<Schema> chainResult(
          SearchResultEntry innerResult,
          ResultHandler<? super Schema> handler)
          throws ErrorResultException
      {
        final DN subschemaDN = getSubschemaSubentryDN(name, innerResult);
        return readSchema(connection, subschemaDN, handler);
      }

    };

    final SearchRequest request = getReadSchemaForEntrySearchRequest(name);
    final FutureResult<SearchResultEntry> innerFuture = connection
        .searchSingleEntry(request, future);
    future.setFutureResult(innerFuture);
    return future;
  }



  /**
   * Reads the schema from the Directory Server which applies to the
   * named entry using the provided connection.
   * <p>
   * If the requested entry or its associated schema are not returned by
   * the Directory Server then the request will fail with an
   * {@link EntryNotFoundException}. More specifically, this method will
   * never return {@code null}.
   * <p>
   * A typical implementation will first read the {@code
   * subschemaSubentry} attribute of the entry in order to locate the
   * schema. However, implementations may choose to perform other
   * optimizations, such as caching.
   *
   * @param connection
   *          A connection to the Directory Server whose schema is to be
   *          read.
   * @param name
   *          The distinguished name of the entry whose schema is to be
   *          located.
   * @return The schema from the Directory Server which applies to the
   *         named entry.
   * @throws ErrorResultException
   *           If the result code indicates that the request failed for
   *           some reason.
   * @throws InterruptedException
   *           If the current thread was interrupted while waiting.
   * @throws UnsupportedOperationException
   *           If the connection does not support search operations.
   * @throws IllegalStateException
   *           If the connection has already been closed, i.e. if
   *           {@code isClosed() == true}.
   * @throws NullPointerException
   *           If the {@code connection} or {@code name} was {@code
   *           null}.
   */
  public static Schema readSchemaForEntry(Connection connection, DN name)
      throws ErrorResultException, InterruptedException,
      UnsupportedOperationException, IllegalStateException,
      NullPointerException
  {
    final SearchRequest request = getReadSchemaForEntrySearchRequest(name);
    final Entry entry = connection.searchSingleEntry(request);
    final DN subschemaDN = getSubschemaSubentryDN(name, entry);

    return readSchema(connection, subschemaDN);
  }



  /**
   * Sets the default schema which should be used by this application.
   * The default schema is initially set to the core schema.
   *
   * @param schema
   *          The default schema which should be used by this
   *          application.
   */
  public static void setDefaultSchema(Schema schema)
  {
    DEFAULT_SCHEMA = schema;
  }



  /**
   * Parses the provided entry as a subschema subentry. Any problems
   * encountered while parsing the entry can be retrieved using the
   * returned schema's {@link #getWarnings()} method.
   *
   * @param entry
   *          The subschema subentry to be parsed.
   * @return The parsed schema.
   */
  public static Schema valueOf(Entry entry)
  {
    final SchemaBuilder builder = new SchemaBuilder(entry.getName()
        .toString());

    Attribute attr = entry.getAttribute(ATTR_LDAP_SYNTAXES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addSyntax(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_ATTRIBUTE_TYPES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addAttributeType(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_OBJECT_CLASSES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addObjectClass(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_MATCHING_RULE_USE);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addMatchingRuleUse(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_MATCHING_RULES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addMatchingRule(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_DIT_CONTENT_RULES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addDITContentRule(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_DIT_STRUCTURE_RULES);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addDITStructureRule(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    attr = entry.getAttribute(ATTR_NAME_FORMS);
    if (attr != null)
    {
      for (final ByteString def : attr)
      {
        try
        {
          builder.addNameForm(def.toString(), true);
        }
        catch (final LocalizedIllegalArgumentException e)
        {
          builder.addWarning(e.getMessageObject());
        }
      }
    }

    return builder.toSchema();
  }



  // Constructs a search request for retrieving the subschemaSubentry
  // attribute from the named entry.
  private static SearchRequest getReadSchemaForEntrySearchRequest(DN dn)
  {
    return Requests.newSearchRequest(dn, SearchScope.BASE_OBJECT,
        Filter.getObjectClassPresentFilter(), SUBSCHEMA_SUBENTRY_ATTRS);
  }



  // Constructs a search request for retrieving the named subschema
  // sub-entry.
  private static SearchRequest getReadSchemaSearchRequest(DN dn)
  {
    return Requests.newSearchRequest(dn, SearchScope.BASE_OBJECT,
        SUBSCHEMA_FILTER, SUBSCHEMA_ATTRS);
  }



  private static DN getSubschemaSubentryDN(DN name, final Entry entry)
      throws ErrorResultException
  {
    final Attribute subentryAttr = entry
        .getAttribute(ATTR_SUBSCHEMA_SUBENTRY);

    if (subentryAttr == null || subentryAttr.isEmpty())
    {
      // Did not get the subschema sub-entry attribute.
      final Result result = Responses.newResult(
          ResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED)
          .setDiagnosticMessage(
              ERR_NO_SUBSCHEMA_SUBENTRY_ATTR.get(name.toString())
                  .toString());
      throw ErrorResultException.wrap(result);
    }

    final String dnString = subentryAttr.iterator().next().toString();
    DN subschemaDN;
    try
    {
      subschemaDN = DN.valueOf(dnString);
    }
    catch (final LocalizedIllegalArgumentException e)
    {
      final Result result = Responses.newResult(
          ResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED)
          .setDiagnosticMessage(
              ERR_INVALID_SUBSCHEMA_SUBENTRY_ATTR.get(name.toString(),
                  dnString, e.getMessageObject()).toString());
      throw ErrorResultException.wrap(result);
    }
    return subschemaDN;
  }



  static MatchingRule getDefaultMatchingRule()
  {
    return CoreSchema.getOctetStringMatchingRule();
  }



  static Syntax getDefaultSyntax()
  {
    return CoreSchema.getOctetStringSyntax();
  }



  private final Impl impl;



  private Schema(Impl impl)
  {
    this.impl = impl;
  }



  Schema(String schemaName, Map<String, Syntax> numericOID2Syntaxes,
      Map<String, MatchingRule> numericOID2MatchingRules,
      Map<String, MatchingRuleUse> numericOID2MatchingRuleUses,
      Map<String, AttributeType> numericOID2AttributeTypes,
      Map<String, ObjectClass> numericOID2ObjectClasses,
      Map<String, NameForm> numericOID2NameForms,
      Map<String, DITContentRule> numericOID2ContentRules,
      Map<Integer, DITStructureRule> id2StructureRules,
      Map<String, List<MatchingRule>> name2MatchingRules,
      Map<String, List<MatchingRuleUse>> name2MatchingRuleUses,
      Map<String, List<AttributeType>> name2AttributeTypes,
      Map<String, List<ObjectClass>> name2ObjectClasses,
      Map<String, List<NameForm>> name2NameForms,
      Map<String, List<DITContentRule>> name2ContentRules,
      Map<String, List<DITStructureRule>> name2StructureRules,
      Map<String, List<NameForm>> objectClass2NameForms,
      Map<String, List<DITStructureRule>> nameForm2StructureRules,
      SchemaCompatOptions options, List<LocalizableMessage> warnings)
  {
    impl = new StrictImpl(schemaName, numericOID2Syntaxes,
        numericOID2MatchingRules, numericOID2MatchingRuleUses,
        numericOID2AttributeTypes, numericOID2ObjectClasses,
        numericOID2NameForms, numericOID2ContentRules,
        id2StructureRules, name2MatchingRules, name2MatchingRuleUses,
        name2AttributeTypes, name2ObjectClasses, name2NameForms,
        name2ContentRules, name2StructureRules, objectClass2NameForms,
        nameForm2StructureRules, options, warnings);
  }



  /**
   * Returns the attribute type with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the attribute type to retrieve.
   * @return The requested attribute type.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested attribute
   *           type was not found or if the provided name is ambiguous.
   */
  public AttributeType getAttributeType(String name)
      throws UnknownSchemaElementException
  {
    return impl.getAttributeType(name);
  }



  /**
   * Returns an unmodifiable collection containing all of the attribute
   * types contained in this schema.
   *
   * @return An unmodifiable collection containing all of the attribute
   *         types contained in this schema.
   */
  public Collection<AttributeType> getAttributeTypes()
  {
    return impl.getAttributeTypes();
  }



  /**
   * Returns an unmodifiable collection containing all of the attribute
   * types having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the attribute types to retrieve.
   * @return An unmodifiable collection containing all of the attribute
   *         types having the specified name or numeric OID.
   */
  public List<AttributeType> getAttributeTypesByName(String name)
  {
    return impl.getAttributeTypesByName(name);
  }



  /**
   * Returns the DIT content rule with the specified name or numeric
   * OID.
   *
   * @param name
   *          The name or OID of the DIT content rule to retrieve.
   * @return The requested DIT content rule.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested DIT content
   *           rule was not found or if the provided name is ambiguous.
   */
  public DITContentRule getDITContentRule(String name)
      throws UnknownSchemaElementException
  {
    return impl.getDITContentRule(name);
  }



  /**
   * Returns an unmodifiable collection containing all of the DIT
   * content rules contained in this schema.
   *
   * @return An unmodifiable collection containing all of the DIT
   *         content rules contained in this schema.
   */
  public Collection<DITContentRule> getDITContentRules()
  {
    return impl.getDITContentRules();
  }



  /**
   * Returns an unmodifiable collection containing all of the DIT
   * content rules having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the DIT content rules to retrieve.
   * @return An unmodifiable collection containing all of the DIT
   *         content rules having the specified name or numeric OID.
   */
  public Collection<DITContentRule> getDITContentRulesByName(String name)
  {
    return impl.getDITContentRulesByName(name);
  }



  /**
   * Returns the DIT structure rule with the specified name or numeric
   * OID.
   *
   * @param ruleID
   *          The ID of the DIT structure rule to retrieve.
   * @return The requested DIT structure rule.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested DIT
   *           structure rule was not found.
   */
  public DITStructureRule getDITStructureRule(int ruleID)
      throws UnknownSchemaElementException
  {
    return impl.getDITStructureRule(ruleID);
  }



  /**
   * Returns an unmodifiable collection containing all of the DIT
   * structure rules having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the DIT structure rules to retrieve.
   * @return An unmodifiable collection containing all of the DIT
   *         structure rules having the specified name or numeric OID.
   */
  public Collection<DITStructureRule> getDITStructureRulesByName(
      String name)
  {
    return impl.getDITStructureRulesByName(name);
  }



  /**
   * Retrieves the DIT structure rules for the provided name form.
   *
   * @param nameForm
   *          The name form.
   * @return The requested DIT structure rules.
   */
  public Collection<DITStructureRule> getDITStructureRulesByNameForm(
      NameForm nameForm)
  {
    return impl.getDITStructureRulesByNameForm(nameForm);
  }



  /**
   * Returns an unmodifiable collection containing all of the DIT
   * structure rules contained in this schema.
   *
   * @return An unmodifiable collection containing all of the DIT
   *         structure rules contained in this schema.
   */
  public Collection<DITStructureRule> getDITStuctureRules()
  {
    return impl.getDITStuctureRules();
  }



  /**
   * Returns the matching rule with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the matching rule to retrieve.
   * @return The requested matching rule.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested matching
   *           rule was not found or if the provided name is ambiguous.
   */
  public MatchingRule getMatchingRule(String name)
      throws UnknownSchemaElementException
  {
    return impl.getMatchingRule(name);
  }



  /**
   * Returns an unmodifiable collection containing all of the matching
   * rules contained in this schema.
   *
   * @return An unmodifiable collection containing all of the matching
   *         rules contained in this schema.
   */
  public Collection<MatchingRule> getMatchingRules()
  {
    return impl.getMatchingRules();
  }



  /**
   * Returns an unmodifiable collection containing all of the matching
   * rules having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the matching rules to retrieve.
   * @return An unmodifiable collection containing all of the matching
   *         rules having the specified name or numeric OID.
   */
  public Collection<MatchingRule> getMatchingRulesByName(String name)
  {
    return impl.getMatchingRulesByName(name);
  }



  /**
   * Returns the matching rule use associated with the provided matching
   * rule.
   *
   * @param matchingRule
   *          The matching rule whose matching rule use is to be
   *          retrieved.
   * @return The requested matching rule use.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested matching
   *           rule use was not found or if the provided name is
   *           ambiguous.
   */
  public MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule)
      throws UnknownSchemaElementException
  {
    return getMatchingRuleUse(matchingRule.getOID());
  }



  /**
   * Returns the matching rule use with the specified name or numeric
   * OID.
   *
   * @param name
   *          The name or OID of the matching rule use to retrieve.
   * @return The requested matching rule use.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested matching
   *           rule use was not found or if the provided name is
   *           ambiguous.
   */
  public MatchingRuleUse getMatchingRuleUse(String name)
      throws UnknownSchemaElementException
  {
    return impl.getMatchingRuleUse(name);
  }



  /**
   * Returns an unmodifiable collection containing all of the matching
   * rule uses contained in this schema.
   *
   * @return An unmodifiable collection containing all of the matching
   *         rule uses contained in this schema.
   */
  public Collection<MatchingRuleUse> getMatchingRuleUses()
  {
    return impl.getMatchingRuleUses();
  }



  /**
   * Returns an unmodifiable collection containing all of the matching
   * rule uses having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the matching rule uses to retrieve.
   * @return An unmodifiable collection containing all of the matching
   *         rule uses having the specified name or numeric OID.
   */
  public Collection<MatchingRuleUse> getMatchingRuleUsesByName(
      String name)
  {
    return impl.getMatchingRuleUsesByName(name);
  }



  /**
   * Returns the name form with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the name form to retrieve.
   * @return The requested name form.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested name form
   *           was not found or if the provided name is ambiguous.
   */
  public NameForm getNameForm(String name)
      throws UnknownSchemaElementException
  {
    return impl.getNameForm(name);
  }



  /**
   * Retrieves the name forms for the specified structural objectclass.
   *
   * @param structuralClass
   *          The structural objectclass for the name form to retrieve.
   * @return The requested name forms
   */
  public Collection<NameForm> getNameFormByObjectClass(
      ObjectClass structuralClass)
  {
    return impl.getNameFormByObjectClass(structuralClass);
  }



  /**
   * Returns an unmodifiable collection containing all of the name forms
   * contained in this schema.
   *
   * @return An unmodifiable collection containing all of the name forms
   *         contained in this schema.
   */
  public Collection<NameForm> getNameForms()
  {
    return impl.getNameForms();
  }



  /**
   * Returns an unmodifiable collection containing all of the name forms
   * having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the name forms to retrieve.
   * @return An unmodifiable collection containing all of the name forms
   *         having the specified name or numeric OID.
   */
  public Collection<NameForm> getNameFormsByName(String name)
  {
    return impl.getNameFormsByName(name);
  }



  /**
   * Returns the object class with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the object class to retrieve.
   * @return The requested object class.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested object class
   *           was not found or if the provided name is ambiguous.
   */
  public ObjectClass getObjectClass(String name)
      throws UnknownSchemaElementException
  {
    return impl.getObjectClass(name);
  }



  /**
   * Returns an unmodifiable collection containing all of the object
   * classes contained in this schema.
   *
   * @return An unmodifiable collection containing all of the object
   *         classes contained in this schema.
   */
  public Collection<ObjectClass> getObjectClasses()
  {
    return impl.getObjectClasses();
  }



  /**
   * Returns an unmodifiable collection containing all of the object
   * classes having the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the object classes to retrieve.
   * @return An unmodifiable collection containing all of the object
   *         classes having the specified name or numeric OID.
   */
  public Collection<ObjectClass> getObjectClassesByName(String name)
  {
    return impl.getObjectClassesByName(name);
  }



  /**
   * Returns the user-friendly name of this schema which may be used for
   * debugging purposes. The format of the schema name is not defined
   * but should contain the distinguished name of the subschema
   * sub-entry for those schemas retrieved from a Directory Server.
   *
   * @return The user-friendly name of this schema which may be used for
   *         debugging purposes.
   */
  public String getSchemaName()
  {
    return impl.getSchemaName();
  }



  /**
   * Returns the syntax with the specified numeric OID.
   *
   * @param numericOID
   *          The OID of the syntax to retrieve.
   * @return The requested syntax.
   * @throws UnknownSchemaElementException
   *           If this is a strict schema and the requested syntax was
   *           not found or if the provided name is ambiguous.
   */
  public Syntax getSyntax(String numericOID)
      throws UnknownSchemaElementException
  {
    return impl.getSyntax(numericOID);
  }



  /**
   * Returns an unmodifiable collection containing all of the syntaxes
   * contained in this schema.
   *
   * @return An unmodifiable collection containing all of the syntaxes
   *         contained in this schema.
   */
  public Collection<Syntax> getSyntaxes()
  {
    return impl.getSyntaxes();
  }



  /**
   * Returns an unmodifiable collection containing all of the warnings
   * that were detected when this schema was constructed.
   *
   * @return An unmodifiable collection containing all of the warnings
   *         that were detected when this schema was constructed.
   */
  public Collection<LocalizableMessage> getWarnings()
  {
    return impl.getWarnings();
  }



  /**
   * Indicates whether or not this schema contains an attribute type
   * with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the attribute type.
   * @return {@code true} if this schema contains an attribute type with
   *         the specified name or numeric OID, otherwise {@code false}.
   */
  public boolean hasAttributeType(String name)
  {
    return impl.hasAttributeType(name);
  }



  /**
   * Indicates whether or not this schema contains a DIT content rule
   * with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the DIT content rule.
   * @return {@code true} if this schema contains a DIT content rule
   *         with the specified name or numeric OID, otherwise {@code
   *         false}.
   */
  public boolean hasDITContentRule(String name)
  {
    return impl.hasDITContentRule(name);
  }



  /**
   * Indicates whether or not this schema contains a DIT structure rule
   * with the specified rule ID.
   *
   * @param ruleID
   *          The ID of the DIT structure rule.
   * @return {@code true} if this schema contains a DIT structure rule
   *         with the specified rule ID, otherwise {@code false}.
   */
  public boolean hasDITStructureRule(int ruleID)
  {
    return impl.hasDITStructureRule(ruleID);
  }



  /**
   * Indicates whether or not this schema contains a matching rule with
   * the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the matching rule.
   * @return {@code true} if this schema contains a matching rule with
   *         the specified name or numeric OID, otherwise {@code false}.
   */
  public boolean hasMatchingRule(String name)
  {
    return impl.hasMatchingRule(name);
  }



  /**
   * Indicates whether or not this schema contains a matching rule use
   * with the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the matching rule use.
   * @return {@code true} if this schema contains a matching rule use
   *         with the specified name or numeric OID, otherwise {@code
   *         false}.
   */
  public boolean hasMatchingRuleUse(String name)
  {
    return impl.hasMatchingRuleUse(name);
  }



  /**
   * Indicates whether or not this schema contains a name form with the
   * specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the name form.
   * @return {@code true} if this schema contains a name form with the
   *         specified name or numeric OID, otherwise {@code false}.
   */
  public boolean hasNameForm(String name)
  {
    return impl.hasNameForm(name);
  }



  /**
   * Indicates whether or not this schema contains an object class with
   * the specified name or numeric OID.
   *
   * @param name
   *          The name or OID of the object class.
   * @return {@code true} if this schema contains an object class with
   *         the specified name or numeric OID, otherwise {@code false}.
   */
  public boolean hasObjectClass(String name)
  {
    return impl.hasObjectClass(name);
  }



  /**
   * Indicates whether or not this schema contains a syntax with the
   * specified numeric OID.
   *
   * @param numericOID
   *          The OID of the syntax.
   * @return {@code true} if this schema contains a syntax with the
   *         specified numeric OID, otherwise {@code false}.
   */
  public boolean hasSyntax(String numericOID)
  {
    return impl.hasSyntax(numericOID);
  }



  /**
   * Indicates whether or not this schema is strict. Attribute type
   * queries in non-strict schema always succeed: if the requested
   * attribute type is not found then a temporary attribute type is
   * created automatically having the Octet String syntax and associated
   * matching rules. Strict schema, on the other hand, throw an
   * {@link UnknownSchemaElementException} whenever an attempt is made
   * to retrieve a non-existent attribute type.
   *
   * @return {@code true} if this schema is strict.
   */
  public boolean isStrict()
  {
    return impl.isStrict();
  }



  /**
   * Returns a non-strict view of this schema. Attribute type queries in
   * non-strict schema always succeed: if the requested attribute type
   * is not found then a temporary attribute type is created
   * automatically having the Octet String syntax and associated
   * matching rules. Strict schema, on the other hand, throw an
   * {@link UnknownSchemaElementException} whenever an attempt is made
   * to retrieve a non-existent attribute type.
   *
   * @return A non-strict view of this schema.
   */
  public Schema nonStrict()
  {
    if (impl.isStrict())
    {
      return new Schema(new NonStrictImpl(impl));
    }
    else
    {
      return this;
    }
  }



  SchemaCompatOptions getSchemaCompatOptions()
  {
    return impl.getSchemaCompatOptions();
  }
}