/*
 * 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 2006-2009 Sun Microsystems, Inc.
 */
package org.opends.server.types;
import java.util.List;
import org.opends.messages.Message;



import java.util.Map;
import java.util.Set;

import org.opends.server.api.AlertGenerator;
import org.opends.server.api.ApproximateMatchingRule;
import org.opends.server.api.AttributeSyntax;
import org.opends.server.api.ChangeNotificationListener;
import org.opends.server.api.ConfigHandler;
import org.opends.server.api.EqualityMatchingRule;
import org.opends.server.api.ExtendedOperationHandler;
import org.opends.server.api.InvokableComponent;
import org.opends.server.api.OrderingMatchingRule;
import org.opends.server.api.SASLMechanismHandler;
import org.opends.server.api.ServerShutdownListener;
import org.opends.server.api.SubstringMatchingRule;
import org.opends.server.api.MatchingRule;
import org.opends.server.config.ConfigEntry;
import org.opends.server.config.ConfigException;
import org.opends.server.core.DirectoryServer;


/**
 * This interface defines a set of methods that may be used by
 * third-party code to obtatin information about the core Directory
 * Server configuration and the instances of various kinds of
 * components that have registered themselves with the server.
 * <BR><BR>
 * Note that this interface is not intended to be implemented by any
 * third-party code.  It is merely used to control which elements are
 * intended for use by external classes.
 */
@org.opends.server.types.PublicAPI(
     stability=org.opends.server.types.StabilityLevel.VOLATILE,
     mayInstantiate=false,
     mayExtend=false,
     mayInvoke=true)
public final class DirectoryConfig
{
  /**
   * Retrieves a reference to the Directory Server crypto manager.
   *
   * @return  A reference to the Directory Server crypto manager.
   */
  public static CryptoManager getCryptoManager()
  {
    return DirectoryServer.getCryptoManager();
  }



  /**
   * Retrieves the operating system on which the Directory Server is
   * running.
   *
   * @return  The operating system on which the Directory Server is
   *          running.
   */
  public static OperatingSystem getOperatingSystem()
  {
    return DirectoryServer.getOperatingSystem();
  }



  /**
   * Retrieves a reference to the Directory Server configuration
   * handler.
   *
   * @return  A reference to the Directory Server configuration
   *          handler.
   */
  public static ConfigHandler getConfigHandler()
  {
    return DirectoryServer.getConfigHandler();
  }



  /**
   * Retrieves the requested entry from the Directory Server
   * configuration.
   *
   * @param  entryDN  The DN of the configuration entry to retrieve.
   *
   * @return  The requested entry from the Directory Server
   *          configuration.
   *
   * @throws  ConfigException  If a problem occurs while trying to
   *                           retrieve the requested entry.
   */
  public static ConfigEntry getConfigEntry(DN entryDN)
         throws ConfigException
  {
    return DirectoryServer.getConfigEntry(entryDN);
  }



  /**
   * Retrieves the path to the root directory for this instance of the
   * Directory Server.
   *
   * @return  The path to the root directory for this instance of the
   *          Directory Server.
  */
  public static String getServerRoot()
  {
    return DirectoryServer.getServerRoot();
  }



  /**
   * Retrieves the time that the Directory Server was started, in
   * milliseconds since the epoch.
   *
   * @return  The time that the Directory Server was started, in
   *          milliseconds since the epoch.
   */
  public static long getStartTime()
  {
    return DirectoryServer.getStartTime();
  }



  /**
   * Retrieves the time that the Directory Server was started,
   * formatted in UTC.
   *
   * @return  The time that the Directory Server was started,
   *          formatted in UTC.
   */
  public static String getStartTimeUTC()
  {
    return DirectoryServer.getStartTimeUTC();
  }



  /**
   * Retrieves a reference to the Directory Server schema.
   *
   * @return  A reference to the Directory Server schema.
   */
  public static Schema getSchema()
  {
    return DirectoryServer.getSchema();
  }



  /**
   * Retrieves the set of matching rules registered with the Directory
   * Server.  The mapping will be between the lowercase name or OID
   * for each matching rule and the matching rule implementation.  The
   * same matching rule instance may be included multiple times with
   * different keys.  The returned map must not be altered by the
   * caller.
   *
   * @return  The set of matching rules registered with the Directory
   *          Server.
   */
  public static Map<String,MatchingRule> getMatchingRules()
  {
    return DirectoryServer.getMatchingRules();
  }



  /**
   * Retrieves the matching rule with the specified name or OID.
   *
   * @param  lowerName  The lowercase name or OID for the matching
   *                    rule to retrieve.
   *
   * @return  The requested matching rule, or <CODE>null</CODE> if no
   *          such matching rule has been defined in the server.
   */
  public static MatchingRule getMatchingRule(String lowerName)
  {
    return DirectoryServer.getMatchingRule(lowerName);
  }



  /**
   * Retrieves the approximate matching rule with the specified name
   * or OID.
   *
   * @param  lowerName  The lowercase name or OID for the approximate
   *                    matching rule to retrieve.
   *
   * @return  The requested approximate matching rule, or
   *          <CODE>null</CODE> if no such matching rule has been
   *          defined in the server.
   */
  public static ApproximateMatchingRule
       getApproximateMatchingRule(String lowerName)
  {
    return DirectoryServer.getApproximateMatchingRule(lowerName);
  }



  /**
   * Retrieves the equality matching rule with the specified name or
   * OID.
   *
   * @param  lowerName  The lowercase name or OID for the equality
   *                    matching rule to retrieve.
   *
   * @return  The requested equality matching rule, or
   *          <CODE>null</CODE> if no such matching rule has been
   *          defined in the server.
   */
  public static EqualityMatchingRule
       getEqualityMatchingRule(String lowerName)
  {
    return DirectoryServer.getEqualityMatchingRule(lowerName);
  }



  /**
   * Retrieves the ordering matching rule with the specified name or
   * OID.
   *
   * @param  lowerName  The lowercase name or OID for the ordering
   *                    matching rule to retrieve.
   *
   * @return  The requested ordering matching rule, or
   *          <CODE>null</CODE> if no such matching rule has been
   *          defined in the server.
   */
  public static OrderingMatchingRule
       getOrderingMatchingRule(String lowerName)
  {
    return DirectoryServer.getOrderingMatchingRule(lowerName);
  }



  /**
   * Retrieves the substring matching rule with the specified name or
   * OID.
   *
   * @param  lowerName  The lowercase name or OID for the substring
   *                    matching rule to retrieve.
   *
   * @return  The requested substring matching rule, or
   *          <CODE>null</CODE> if no such matching rule has been
   *          defined in the server.
   */
  public static SubstringMatchingRule
       getSubstringMatchingRule(String lowerName)
  {
    return DirectoryServer.getSubstringMatchingRule(lowerName);
  }



  /**
   * Retrieves the set of objectclasses registered with the Directory
   * Server.  The mapping will be between the lowercase name or OID
   * for each objectclass and the objectclass implementation.  The
   * same objectclass instance may be included multiple times with
   * different keys.  The returned map must not be altered by the
   * caller.
   *
   * @return  The set of objectclasses defined in the Directory
   *          Server.
   */
  public static Map<String,ObjectClass> getObjectClasses()
  {
    return DirectoryServer.getObjectClasses();
  }



  /**
   * Retrieves the objectclass for the provided lowercase name or OID.
   * It can optionally return a generated "default" version if the
   * requested objectclass is not defined in the schema.
   *
   * @param  lowerName      The lowercase name or OID for the
   *                        objectclass to retrieve.
   * @param  returnDefault  Indicates whether to generate a default
   *                        version if the requested objectclass is
   *                        not defined in the server schema.
   *
   * @return  The objectclass type, or <CODE>null</CODE> if there is
   *          no objectclass with the specified name or OID defined in
   *          the server schema and a default class should not be
   *          returned.
   */
  public static ObjectClass
       getObjectClass(String lowerName, boolean returnDefault)
  {
    return DirectoryServer.getObjectClass(lowerName, returnDefault);
  }



  /**
   * Retrieves the "top" objectClass, which should be the topmost
   * objectclass in the inheritance chain for most other
   * objectclasses.
   *
   * @return  The "top" objectClass.
   */
  public static ObjectClass getTopObjectClass()
  {
    return DirectoryServer.getTopObjectClass();
  }



  /**
   * Retrieves the set of attribute type definitions that have been
   * defined in the Directory Server.  The mapping will be between the
   * lowercase name or OID for each attribute type and the attribute
   * type implementation.  The same attribute type may be included
   * multiple times with different keys.  The returned map must not be
   * altered by the caller.
   *
   * @return The set of attribute type definitions that have been
   *         defined in the Directory Server.
   */
  public static Map<String,AttributeType> getAttributeTypes()
  {
    return DirectoryServer.getAttributeTypes();
  }



  /**
   * Retrieves the attribute type for the provided lowercase name or
   * OID.  It can optionally return a generated "default" version if
   * the requested attribute type is not defined in the schema.
   *
   * @param  lowerName      The lowercase name or OID for the
   *                        attribute type to retrieve.
   * @param  returnDefault  Indicates whether to generate a default
   *                        version if the requested attribute type is
   *                        not defined in the server schema.
   *
   * @return  The requested attribute type, or <CODE>null</CODE> if
   *          there is no attribute with the specified type defined in
   *          the server schema and a default type should not be
   *          returned.
   */
  public static AttributeType
       getAttributeType(String lowerName, boolean returnDefault)
  {
    return DirectoryServer.getAttributeType(lowerName, returnDefault);
  }



  /**
   * Retrieves the attribute type for the "objectClass" attribute.
   *
   * @return  The attribute type for the "objectClass" attribute.
   */
  public static AttributeType getObjectClassAttributeType()
  {
    return DirectoryServer.getObjectClassAttributeType();
  }



  /**
   * Retrieves the set of attribute syntaxes defined in the Directory
   * Server.  The mapping will be between the OID and the
   * corresponding syntax implementation.  The returned map must not
   * be altered by the caller.
   *
   * @return  The set of attribute syntaxes defined in the Directory
   *          Server.
   */
  public static Map<String,AttributeSyntax>
       getAttributeSyntaxes()
  {
    return DirectoryServer.getAttributeSyntaxes();
  }



  /**
   * Retrieves the requested attribute syntax.
   *
   * @param  oid           The OID of the syntax to retrieve.
   * @param  allowDefault  Indicates whether to return the default
   *                       attribute syntax if the requested syntax is
   *                       unknown.
   *
   * @return  The requested attribute syntax, the default syntax if
   *          the requested syntax is unknown and the caller has
   *          indicated that the default is acceptable, or
   *          <CODE>null</CODE> otherwise.
   */
  public static AttributeSyntax
       getAttributeSyntax(String oid, boolean allowDefault)
  {
    return DirectoryServer.getAttributeSyntax(oid, allowDefault);
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema.
   */
  public static AttributeSyntax getDefaultAttributeSyntax()
  {
    return DirectoryServer.getDefaultAttributeSyntax();
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema and are
   * meant to store binary values.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema and
   *          are meant to store binary values.
   */
  public static AttributeSyntax getDefaultBinarySyntax()
  {
    return DirectoryServer.getDefaultBinarySyntax();
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema and are
   * meant to store Boolean values.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema and
   *          are meant to store Boolean values.
   */
  public static AttributeSyntax getDefaultBooleanSyntax()
  {
    return DirectoryServer.getDefaultBooleanSyntax();
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema and are
   * meant to store DN values.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema and
   *          are meant to store DN values.
   */
  public static AttributeSyntax getDefaultDNSyntax()
  {
    return DirectoryServer.getDefaultDNSyntax();
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema and are
   * meant to store integer values.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema and
   *          are meant to store integer values.
   */
  public static AttributeSyntax getDefaultIntegerSyntax()
  {
    return DirectoryServer.getDefaultIntegerSyntax();
  }



  /**
   * Retrieves the default attribute syntax that should be used for
   * attributes that are not defined in the server schema and are
   * meant to store string values.
   *
   * @return  The default attribute syntax that should be used for
   *          attributes that are not defined in the server schema and
   *          are meant to store string values.
   */
  public static AttributeSyntax getDefaultStringSyntax()
  {
    return DirectoryServer.getDefaultStringSyntax();
  }



  /**
   * Retrieves the set of matching rule uses defined in the Directory
   * Server.  The mapping will be between the matching rule and its
   * corresponding matching rule use.  The returned map must not be
   * altered by the caller.
   *
   * @return  The set of matching rule uses defined in the Directory
   *          Server.
   */
  public static Map<MatchingRule,MatchingRuleUse>
       getMatchingRuleUses()
  {
    return DirectoryServer.getMatchingRuleUses();
  }



  /**
   * Retrieves the matching rule use associated with the provided
   * matching rule.
   *
   * @param  matchingRule  The matching rule for which to retrieve the
   *                       matching rule use.
   *
   * @return  The matching rule use for the provided matching rule, or
   *          <CODE>null</CODE> if none is defined.
   */
  public static MatchingRuleUse
       getMatchingRuleUse(MatchingRule matchingRule)
  {
    return DirectoryServer.getMatchingRuleUse(matchingRule);
  }



  /**
   * Retrieves the set of DIT content rules defined in the Directory
   * Server.  The mapping will be between the structural objectclass
   * and its corresponding DIT content rule.  The returned map must
   * not be altered by the caller.
   *
   * @return  The set of DIT content rules defined in the Directory
   *          Server.
   */
  public static Map<ObjectClass,DITContentRule>
       getDITContentRules()
  {
    return DirectoryServer.getDITContentRules();
  }



  /**
   * Retrieves the DIT content rule associated with the specified
   * objectclass.
   *
   * @param  objectClass  The objectclass for which to retrieve the
   *                      associated DIT content rule.
   *
   * @return  The requested DIT content rule, or <CODE>null</CODE> if
   *          no such rule is defined in the schema.
   */
  public static DITContentRule
       getDITContentRule(ObjectClass objectClass)
  {
    return DirectoryServer.getDITContentRule(objectClass);
  }



  /**
   * Retrieves the set of DIT structure rules defined in the Directory
   * Server.  The mapping will be between the name form and its
   * corresponding DIT structure rule.  The returned map must not be
   * altered by the caller.
   *
   * @return  The set of DIT structure rules defined in the Directory
   *          Server.
   */
  public static Map<NameForm,DITStructureRule>
       getDITStructureRules()
  {
    return DirectoryServer.getDITStructureRules();
  }



  /**
   * Retrieves the DIT structure rule associated with the provided
   * rule ID.
   *
   * @param  ruleID  The rule ID for which to retrieve the associated
   *                 DIT structure rule.
   *
   * @return  The requested DIT structure rule, or <CODE>null</CODE>
   *          if no such rule is defined.
   */
  public static DITStructureRule getDITStructureRule(int ruleID)
  {
    return DirectoryServer.getDITStructureRule(ruleID);
  }



  /**
   * Retrieves the DIT structure rule associated with the provided
   * name form.
   *
   * @param  nameForm  The name form for which to retrieve the
   *                   associated DIT structure rule.
   *
   * @return  The requested DIT structure rule, or <CODE>null</CODE>
   *          if no such rule is defined.
   */
  public static DITStructureRule
       getDITStructureRule(NameForm nameForm)
  {
    return DirectoryServer.getDITStructureRule(nameForm);
  }



  /**
   * Retrieves the set of name forms defined in the Directory Server.
   * The mapping will be between the structural objectclass and its
   * corresponding name forms.  The returned map must not be altered
   * by the caller.
   *
   * @return  The set of name forms defined in the Directory Server.
   */
  public static Map<ObjectClass,List<NameForm>> getNameForms()
  {
    return DirectoryServer.getNameForms();
  }



  /**
   * Retrieves the list of name forms associated with the specified
   * structural objectclass.
   *
   * @param  objectClass  The structural objectclass for which to
   *                      retrieve the  associated name form.
   *
   * @return  The list of requested name forms, or <CODE>null</CODE>
   *           if no such name form is defined in the schema.
   */
  public static List<NameForm> getNameForm(ObjectClass objectClass)
  {
    return DirectoryServer.getNameForm(objectClass);
  }



  /**
   * Retrieves the name form associated with the specified name or
   * OID.
   *
   * @param  lowerName  The name or OID of the name form to retrieve,
   *                    formatted in all lowercase characters.
   *
   * @return  The requested name form, or <CODE>null</CODE> if no such
   *          name form is defined in the schema.
   */
  public static NameForm getNameForm(String lowerName)
  {
    return DirectoryServer.getNameForm(lowerName);
  }



  /**
   * Registers the provided invokable component with the Directory
   * Server.
   *
   * @param  component  The invokable component to register.
   */
  public static void registerInvokableComponent(
                                InvokableComponent component)
  {
    DirectoryServer.registerInvokableComponent(component);
  }



  /**
   * Deregisters the provided invokable component with the Directory
   * Server.
   *
   * @param  component  The invokable component to deregister.
   */
  public static void deregisterInvokableComponent(
                                InvokableComponent component)
  {
    DirectoryServer.deregisterInvokableComponent(component);
  }



  /**
   * Registers the provided alert generator with the Directory Server.
   *
   * @param  alertGenerator  The alert generator to register.
   */
  public static void registerAlertGenerator(
                                AlertGenerator alertGenerator)
  {
    DirectoryServer.registerAlertGenerator(alertGenerator);
  }



  /**
   * Deregisters the provided alert generator with the Directory
   * Server.
   *
   * @param  alertGenerator  The alert generator to deregister.
   */
  public static void deregisterAlertGenerator(
                                AlertGenerator alertGenerator)
  {
    DirectoryServer.deregisterAlertGenerator(alertGenerator);
  }



  /**
   * Sends an alert notification with the provided information.
   *
   * @param  generator     The alert generator that created the alert.
   * @param  alertType     The alert type name for this alert.
   * @param  alertMessage  A message (possibly <CODE>null</CODE>) that
   *                       can provide more information about this
   *                       alert.
   */
  public static void
       sendAlertNotification(AlertGenerator generator,
                             String alertType,
                             Message alertMessage)
  {
    DirectoryServer.sendAlertNotification(generator, alertType,
            alertMessage);
  }



  /**
   * Retrieves the result code that should be used when the Directory
   * Server encounters an internal server error.
   *
   * @return  The result code that should be used when the Directory
   *          Server encounters an internal server error.
   */
  public static ResultCode getServerErrorResultCode()
  {
    return DirectoryServer.getServerErrorResultCode();
  }



  /**
   * Retrieves the entry with the requested DN.  It will first
   * determine which backend should be used for this DN and will then
   * use that backend to retrieve the entry.  The caller must already
   * hold the appropriate lock on the specified entry.
   *
   * @param  entryDN  The DN of the entry to retrieve.
   *
   * @return  The requested entry, or <CODE>null</CODE> if it does not
   *          exist.
   *
   * @throws  DirectoryException  If a problem occurs while attempting
   *                              to retrieve the entry.
   */
  public static Entry getEntry(DN entryDN)
         throws DirectoryException
  {
    return DirectoryServer.getEntry(entryDN);
  }



  /**
   * Indicates whether the specified entry exists in the Directory
   * Server.  The caller is not required to hold any locks when
   * invoking this method.
   *
   * @param  entryDN  The DN of the entry for which to make the
   *                  determination.
   *
   * @return  <CODE>true</CODE> if the specified entry exists in one
   *          of the backends, or <CODE>false</CODE> if it does not.
   *
   * @throws  DirectoryException  If a problem occurs while attempting
   *                              to make the determination.
   */
  public static boolean entryExists(DN entryDN)
         throws DirectoryException
  {
    return DirectoryServer.entryExists(entryDN);
  }



  /**
   * Retrieves the set of OIDs for the supported controls registered
   * with the Directory Server.
   *
   * @return  The set of OIDS for the supported controls registered
   *          with the Directory Server.
   */
  public static Set<String> getSupportedControls()
  {
    return DirectoryServer.getSupportedControls();
  }



  /**
   * Indicates whether the specified OID is registered with the
   * Directory Server as a supported control.
   *
   * @param  controlOID  The OID of the control for which to make the
   *                     determination.
   *
   * @return  <CODE>true</CODE> if the specified OID is registered
   *          with the server as a supported control, or
   *          <CODE>false</CODE> if not.
   */
  public static boolean isSupportedControl(String controlOID)
  {
    return DirectoryServer.isSupportedControl(controlOID);
  }



  /**
   * Registers the provided OID as a supported control for the
   * Directory Server.  This will have no effect if the specified
   * control OID is already present in the list of supported controls.
   *
   * @param  controlOID  The OID of the control to register as a
   *                     supported control.
   */
  public static void registerSupportedControl(String controlOID)
  {
    DirectoryServer.registerSupportedControl(controlOID);
  }



  /**
   * Deregisters the provided OID as a supported control for the
   * Directory Server.  This will have no effect if the specified
   * control OID is not present in the list of supported controls.
   *
   * @param  controlOID  The OID of the control to deregister as a
   *                     supported control.
   */
  public static void
       deregisterSupportedControl(String controlOID)
  {
    DirectoryServer.deregisterSupportedControl(controlOID);
  }



  /**
   * Retrieves the set of OIDs for the supported features registered
   * with the Directory Server.
   *
   * @return  The set of OIDs for the supported features registered
   *          with the Directory Server.
   */
  public static Set<String> getSupportedFeatures()
  {
    return DirectoryServer.getSupportedFeatures();
  }



  /**
   * Indicates whether the specified OID is registered with the
   * Directory Server as a supported feature.
   *
   * @param  featureOID  The OID of the feature for which to make the
   *                     determination.
   *
   * @return  <CODE>true</CODE> if the specified OID is registered
   *          with the server as a supported feature, or
   *          <CODE>false</CODE> if not.
   */
  public static boolean isSupportedFeature(String featureOID)
  {
    return DirectoryServer.isSupportedFeature(featureOID);
  }



  /**
   * Registers the provided OID as a supported feature for the
   * Directory Server.  This will have no effect if the specified
   * feature OID is already present in the list of supported features.
   *
   * @param  featureOID  The OID of the feature to register as a
   *                     supported feature.
   */
  public static void registerSupportedFeature(String featureOID)
  {
    DirectoryServer.registerSupportedFeature(featureOID);
  }



  /**
   * Deregisters the provided OID as a supported feature for the
   * Directory Server.  This will have no effect if the specified
   * feature OID is not present in the list of supported features.
   *
   * @param  featureOID  The OID of the feature to deregister as a
   *                     supported feature.
   */
  public static void
       deregisterSupportedFeature(String featureOID)
  {
    DirectoryServer.deregisterSupportedFeature(featureOID);
  }



  /**
   * Retrieves the set of extended operations that may be processed by
   * the Directory Server.  The mapping will be between the OID and
   * the extended operation handler providing the logic for the
   * extended operation with that OID.  The returned map must not be
   * altered by the caller.
   *
   * @return  The set of extended operations that may be processed by
   *          the Directory Server.
   */
  public static Map<String,ExtendedOperationHandler>
                     getSupportedExtensions()
  {
    return DirectoryServer.getSupportedExtensions();
  }



  /**
   * Retrieves the handler for the extended operation for the provided
   * extended operation OID.
   *
   * @param  oid  The OID of the extended operation to retrieve.
   *
   * @return  The handler for the specified extended operation, or
   *          <CODE>null</CODE> if there is none.
   */
  public static ExtendedOperationHandler
       getExtendedOperationHandler(String oid)
  {
    return DirectoryServer.getExtendedOperationHandler(oid);
  }



  /**
   * Registers the provided extended operation handler with the
   * Directory Server.
   *
   * @param  oid      The OID for the extended operation to register.
   * @param  handler  The extended operation handler to register with
   *                  the Directory Server.
   */
  public static void registerSupportedExtension(String oid,
                          ExtendedOperationHandler handler)
  {
    DirectoryServer.registerSupportedExtension(oid, handler);
  }



  /**
   * Deregisters the provided extended operation handler with the
   * Directory Server.
   *
   * @param  oid  The OID for the extended operation to deregister.
   */
  public static void deregisterSupportedExtension(String oid)
  {
    DirectoryServer.deregisterSupportedExtension(oid);
  }



  /**
   * Retrieves the set of SASL mechanisms that are supported by the
   * Directory Server.  The mapping will be between the mechanism name
   * and the SASL mechanism handler that implements support for that
   * mechanism.  The returned map must not be altered by the caller.
   *
   * @return  The set of SASL mechanisms that are supported by the
   *          Directory Server.
   */
  public static Map<String,SASLMechanismHandler>
                     getSupportedSASLMechanisms()
  {
    return DirectoryServer.getSupportedSASLMechanisms();
  }



  /**
   * Retrieves the handler for the specified SASL mechanism.
   *
   * @param  name  The name of the SASL mechanism to retrieve.
   *
   * @return  The handler for the specified SASL mechanism, or
   *          <CODE>null</CODE> if there is none.
   */
  public static SASLMechanismHandler
       getSASLMechanismHandler(String name)
  {
    return DirectoryServer.getSASLMechanismHandler(name);
  }



  /**
   * Registers the provided SASL mechanism handler with the Directory
   * Server.
   *
   * @param  name     The name of the SASL mechanism to be registered.
   * @param  handler  The SASL mechanism handler to register with the
   *                  Directory Server.
   */
  public static void
       registerSASLMechanismHandler(String name,
                                    SASLMechanismHandler handler)
  {
    DirectoryServer.registerSASLMechanismHandler(name, handler);
  }



  /**
   * Deregisters the provided SASL mechanism handler with the
   * Directory Server.
   *
   * @param  name  The name of the SASL mechanism to be deregistered.
   */
  public static void deregisterSASLMechanismHandler(String name)
  {
    DirectoryServer.deregisterSASLMechanismHandler(name);
  }



  /**
   * Registers the provided change notification listener with the
   * Directory Server so that it will be notified of any add, delete,
   * modify, or modify DN operations that are performed.
   *
   * @param  changeListener  The change notification listener to
   *                         register with the Directory Server.
   */
  public static void
       registerChangeNotificationListener(
            ChangeNotificationListener changeListener)
  {
    DirectoryServer.registerChangeNotificationListener(
                         changeListener);
  }



  /**
   * Deregisters the provided change notification listener with the
   * Directory Server so that it will no longer be notified of any
   * add, delete, modify, or modify DN operations that are performed.
   *
   * @param  changeListener  The change notification listener to
   *                         deregister with the Directory Server.
   */
  public static void deregisterChangeNotificationListener(
                          ChangeNotificationListener changeListener)
  {
    DirectoryServer.deregisterChangeNotificationListener(
                         changeListener);
  }



  /**
   * Registers the provided shutdown listener with the Directory
   * Server so that it will be notified when the server shuts down.
   *
   * @param  listener  The shutdown listener to register with the
   *                   Directory Server.
   */
  public static void
       registerShutdownListener(ServerShutdownListener listener)
  {
    DirectoryServer.registerShutdownListener(listener);
  }



  /**
   * Deregisters the provided shutdown listener with the Directory
   * Server.
   *
   * @param  listener  The shutdown listener to deregister with the
   *                   Directory Server.
   */
  public static void
       deregisterShutdownListener(ServerShutdownListener listener)
  {
    DirectoryServer.deregisterShutdownListener(listener);
  }



  /**
   * Retrieves the full version string for the Directory Server.
   *
   * @return  The full version string for the Directory Server.
   */
  public static String getVersionString()
  {
    return DirectoryServer.getVersionString();
  }
}

