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


import org.opends.server.protocols.ldap.LDAPResultCode;
import org.opends.server.util.Validator;

import static org.opends.messages.CoreMessages.*;



/**
 * This enumeration defines the set of possible result codes that may
 * be used for providing clients with information about result of
 * processing an operation.
 */
@org.opends.server.types.PublicAPI(
     stability=org.opends.server.types.StabilityLevel.UNCOMMITTED,
     mayInstantiate=false,
     mayExtend=false,
     mayInvoke=true)
public enum ResultCode
{
  /**
   * The result code that should only be used if the actual result
   * code has not yet been determined.
   */
  UNDEFINED(-1, INFO_RESULT_UNDEFINED.get()),



  /**
   * The result code that indicates that the operation completed
   * successfully.
   */
  SUCCESS(LDAPResultCode.SUCCESS, INFO_RESULT_SUCCESS.get()),



  /**
   * The result code that indicates that an internal error prevented
   * the operation from being processed properly.
   */
  OPERATIONS_ERROR(LDAPResultCode.OPERATIONS_ERROR,
                   INFO_RESULT_OPERATIONS_ERROR.get()),



  /**
   * The result code that indicates that the client sent a malformed
   * or illegal request to the server.
   */
  PROTOCOL_ERROR(LDAPResultCode.PROTOCOL_ERROR,
                 INFO_RESULT_PROTOCOL_ERROR.get()),



  /**
   * The result code that indicates that a time limit was exceeded
   * while attempting to process the request.
   */
  TIME_LIMIT_EXCEEDED(LDAPResultCode.TIME_LIMIT_EXCEEDED,
                      INFO_RESULT_TIME_LIMIT_EXCEEDED.get()),



  /**
   * The result code that indicates that a size limit was exceeded
   * while attempting to process the request.
   */
  SIZE_LIMIT_EXCEEDED(LDAPResultCode.SIZE_LIMIT_EXCEEDED,
                      INFO_RESULT_SIZE_LIMIT_EXCEEDED.get()),



  /**
   * The result code that indicates that the attribute value assertion
   * included in a compare request did not match the targeted entry.
   */
  COMPARE_FALSE(LDAPResultCode.COMPARE_FALSE,
                INFO_RESULT_COMPARE_FALSE.get()),



  /**
   * The result code that indicates that the attribute value assertion
   * included in a compare request did match the targeted entry.
   */
  COMPARE_TRUE(LDAPResultCode.COMPARE_TRUE,
               INFO_RESULT_COMPARE_TRUE.get()),



  /**
   * The result code that indicates that the requested authentication
   * attempt failed because it referenced an invalid SASL mechanism.
   */
  AUTH_METHOD_NOT_SUPPORTED(LDAPResultCode.AUTH_METHOD_NOT_SUPPORTED,
                         INFO_RESULT_AUTH_METHOD_NOT_SUPPORTED.get()),



  /**
   * The result code that indicates that the requested operation could
   * not be processed because it requires that the client has
   * completed a strong form of authentication.
   */
  STRONG_AUTH_REQUIRED(LDAPResultCode.STRONG_AUTH_REQUIRED,
                       INFO_RESULT_STRONG_AUTH_REQUIRED.get()),



  /**
   * The result code that indicates that a referral was encountered.
   */
  REFERRAL(LDAPResultCode.REFERRAL, INFO_RESULT_REFERRAL.get()),



  /**
   * The result code that indicates that processing on the requested
   * operation could not continue because an administrative limit was
   * exceeded.
   */
  ADMIN_LIMIT_EXCEEDED(LDAPResultCode.ADMIN_LIMIT_EXCEEDED,
                       INFO_RESULT_ADMIN_LIMIT_EXCEEDED.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it included a critical extension that is
   * unsupported or inappropriate for that request.
   */
  UNAVAILABLE_CRITICAL_EXTENSION(
       LDAPResultCode.UNAVAILABLE_CRITICAL_EXTENSION,
       INFO_RESULT_UNAVAILABLE_CRITICAL_EXTENSION.get()),



  /**
   * The result code that indicates that the requested operation could
   * not be processed because it requires confidentiality for the
   * communication between the client and the server.
   */
  CONFIDENTIALITY_REQUIRED(LDAPResultCode.CONFIDENTIALITY_REQUIRED,
                          INFO_RESULT_CONFIDENTIALITY_REQUIRED.get()),



  /**
   * The result code that should be used for intermediate responses in
   * multi-stage SASL bind operations.
   */
  SASL_BIND_IN_PROGRESS(LDAPResultCode.SASL_BIND_IN_PROGRESS,
                        INFO_RESULT_SASL_BIND_IN_PROGRESS.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it targeted an attribute or attribute value that
   * did not exist in the specified entry.
   */
  NO_SUCH_ATTRIBUTE(LDAPResultCode.NO_SUCH_ATTRIBUTE,
                    INFO_RESULT_NO_SUCH_ATTRIBUTE.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it referenced an attribute that is not defined in
   * the server schema.
   */
  UNDEFINED_ATTRIBUTE_TYPE(LDAPResultCode.UNDEFINED_ATTRIBUTE_TYPE,
                          INFO_RESULT_UNDEFINED_ATTRIBUTE_TYPE.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it attempted to perform an inappropriate type of
   * matching against an attribute.
   */
  INAPPROPRIATE_MATCHING(LDAPResultCode.INAPPROPRIATE_MATCHING,
                         INFO_RESULT_INAPPROPRIATE_MATCHING.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have violated some constraint defined in
   * the server.
   */
  CONSTRAINT_VIOLATION(LDAPResultCode.CONSTRAINT_VIOLATION,
                       INFO_RESULT_CONSTRAINT_VIOLATION.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have resulted in a conflict with an
   * existing attribute or attribute value in the target entry.
   */
  ATTRIBUTE_OR_VALUE_EXISTS(LDAPResultCode.ATTRIBUTE_OR_VALUE_EXISTS,
                         INFO_RESULT_ATTRIBUTE_OR_VALUE_EXISTS.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it violated the syntax for a specified attribute.
   */
  INVALID_ATTRIBUTE_SYNTAX(LDAPResultCode.INVALID_ATTRIBUTE_SYNTAX,
                          INFO_RESULT_INVALID_ATTRIBUTE_SYNTAX.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it referenced an entry that does not exist.
   */
  NO_SUCH_OBJECT(LDAPResultCode.NO_SUCH_OBJECT,
                 INFO_RESULT_NO_SUCH_OBJECT.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it attempted to perform an illegal operation on an
   * alias.
   */
  ALIAS_PROBLEM(LDAPResultCode.ALIAS_PROBLEM,
                INFO_RESULT_ALIAS_PROBLEM.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have resulted in an entry with an invalid
   * or malformed DN.
   */
  INVALID_DN_SYNTAX(LDAPResultCode.INVALID_DN_SYNTAX,
                    INFO_RESULT_INVALID_DN_SYNTAX.get()),



  /**
   * The result code that indicates that a problem was encountered
   * while attempting to dereference an alias for a search operation.
   */
  ALIAS_DEREFERENCING_PROBLEM(
       LDAPResultCode.ALIAS_DEREFERENCING_PROBLEM,
       INFO_RESULT_ALIAS_DEREFERENCING_PROBLEM.get()),



  /**
   * The result code that indicates that an authentication attempt
   * failed because the requested type of authentication was not
   * appropriate for the targeted entry.
   */
  INAPPROPRIATE_AUTHENTICATION(
       LDAPResultCode.INAPPROPRIATE_AUTHENTICATION,
       INFO_RESULT_INAPPROPRIATE_AUTHENTICATION.get()),



  /**
   * The result code that indicates that an authentication attempt
   * failed because the user did not provide a valid set of
   * credentials.
   */
  INVALID_CREDENTIALS(LDAPResultCode.INVALID_CREDENTIALS,
                      INFO_RESULT_INVALID_CREDENTIALS.get()),



  /**
   * The result code that indicates that the client does not have
   * sufficient permission to perform the requested operation.
   */
  INSUFFICIENT_ACCESS_RIGHTS(
       LDAPResultCode.INSUFFICIENT_ACCESS_RIGHTS,
       INFO_RESULT_INSUFFICIENT_ACCESS_RIGHTS.get()),



  /**
   * The result code that indicates that the server is too busy to
   * process the requested operation.
   */
  BUSY(LDAPResultCode.BUSY, INFO_RESULT_BUSY.get()),



  /**
   * The result code that indicates that either the entire server or
   * one or more required resources were not available for use in
   * processing the request.
   */
  UNAVAILABLE(LDAPResultCode.UNAVAILABLE,
          INFO_RESULT_UNAVAILABLE.get()),



  /**
   * The result code that indicates that the server is unwilling to
   * perform the requested operation.
   */
  UNWILLING_TO_PERFORM(LDAPResultCode.UNWILLING_TO_PERFORM,
                       INFO_RESULT_UNWILLING_TO_PERFORM.get()),



  /**
   * The result code that indicates that a referral or chaining
   * loop was detected while processing the request.
   */
  LOOP_DETECT(LDAPResultCode.LOOP_DETECT,
          INFO_RESULT_LOOP_DETECT.get()),



  /**
   * The result code that indicates that a search request included a
   * VLV request control without a server-side sort control.
   */
  SORT_CONTROL_MISSING(LDAPResultCode.SORT_CONTROL_MISSING,
                       INFO_RESULT_SORT_CONTROL_MISSING.get()),



  /**
   * The result code that indicates that a search request included a
   * VLV request control with an invalid offset.
   */
  OFFSET_RANGE_ERROR(LDAPResultCode.OFFSET_RANGE_ERROR,
                     INFO_RESULT_OFFSET_RANGE_ERROR.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have violated the server's naming
   * configuration.
   */
  NAMING_VIOLATION(LDAPResultCode.NAMING_VIOLATION,
                   INFO_RESULT_NAMING_VIOLATION.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have resulted in an entry that violated
   * the server schema.
   */
  OBJECTCLASS_VIOLATION(LDAPResultCode.OBJECTCLASS_VIOLATION,
                        INFO_RESULT_OBJECTCLASS_VIOLATION.get()),



  /**
   * The result code that indicates that the requested operation is
   * not allowed for non-leaf entries.
   */
  NOT_ALLOWED_ON_NONLEAF(LDAPResultCode.NOT_ALLOWED_ON_NONLEAF,
                         INFO_RESULT_NOT_ALLOWED_ON_NONLEAF.get()),



  /**
   * The result code that indicates that the requested operation is
   * not allowed on an RDN attribute.
   */
  NOT_ALLOWED_ON_RDN(LDAPResultCode.NOT_ALLOWED_ON_RDN,
                     INFO_RESULT_NOT_ALLOWED_ON_RDN.get()),



  /**
   * The result code that indicates that the requested operation
   * failed because it would have resulted in an entry that conflicts
   * with an entry that already exists.
   */
  ENTRY_ALREADY_EXISTS(LDAPResultCode.ENTRY_ALREADY_EXISTS,
                       INFO_RESULT_ENTRY_ALREADY_EXISTS.get()),



  /**
   * The result code that indicates that the operation could not be
   * processed because it would have modified the objectclasses
   * associated with an entry in an illegal manner.
   */
  OBJECTCLASS_MODS_PROHIBITED(
       LDAPResultCode.OBJECTCLASS_MODS_PROHIBITED,
       INFO_RESULT_OBJECTCLASS_MODS_PROHIBITED.get()),



  /**
   * The result code that indicates that the operation could not be
   * processed because it would impact multiple DSAs or other
   * repositories.
   */
  AFFECTS_MULTIPLE_DSAS(LDAPResultCode.AFFECTS_MULTIPLE_DSAS,
                        INFO_RESULT_AFFECTS_MULTIPLE_DSAS.get()),



  /**
   * The result code that indicates that the operation could not be
   * processed because there was an error while processing the virtual
   * list view control.
   */
  VIRTUAL_LIST_VIEW_ERROR(LDAPResultCode.VIRTUAL_LIST_VIEW_ERROR,
                          INFO_RESULT_VIRTUAL_LIST_VIEW_ERROR.get()),



  /**
   * The result code that should be used if no other result code is
   * appropriate.
   */
  OTHER(LDAPResultCode.OTHER, INFO_RESULT_OTHER.get()),



  /**
   * The client-side result code that should be used if an established
   * connection is lost.  This should not be used over protocol.
   */
  CLIENT_SIDE_SERVER_DOWN(LDAPResultCode.CLIENT_SIDE_SERVER_DOWN,
                          INFO_RESULT_CLIENT_SIDE_SERVER_DOWN.get()),



  /**
   * The client-side result code that should be used if a local
   * (client-side) error occurs.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_LOCAL_ERROR(LDAPResultCode.CLIENT_SIDE_LOCAL_ERROR,
                          INFO_RESULT_CLIENT_SIDE_LOCAL_ERROR.get()),



  /**
   * The client-side result code that should be used if an error
   * occurs while encoding a request.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_ENCODING_ERROR(
       LDAPResultCode.CLIENT_SIDE_ENCODING_ERROR,
       INFO_RESULT_CLIENT_SIDE_ENCODING_ERROR.get()),



  /**
   * The client-side result code that should be used if an error
   * occurs while decoding a response.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_DECODING_ERROR(
       LDAPResultCode.CLIENT_SIDE_DECODING_ERROR,
       INFO_RESULT_CLIENT_SIDE_DECODING_ERROR.get()),



  /**
   * The client-side result code that should be used if a client-side
   * timeout occurs.  This should not be used over protocol.
   */
  CLIENT_SIDE_TIMEOUT(LDAPResultCode.CLIENT_SIDE_TIMEOUT,
                      INFO_RESULT_CLIENT_SIDE_TIMEOUT.get()),



  /**
   * The client-side result code that should be used if an unknown or
   * unsupported authentication mechanism is requested.  This should
   * not be used over protocol.
   */
  CLIENT_SIDE_AUTH_UNKNOWN(LDAPResultCode.CLIENT_SIDE_AUTH_UNKNOWN,
                         INFO_RESULT_CLIENT_SIDE_AUTH_UNKNOWN.get()),



  /**
   * The client-side result code that should be used if a malformed
   * search filter is provided.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_FILTER_ERROR(LDAPResultCode.CLIENT_SIDE_FILTER_ERROR,
                         INFO_RESULT_CLIENT_SIDE_FILTER_ERROR.get()),



  /**
   * The client-side result code that should be used if a user
   * cancelled a client-side operation.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_USER_CANCELLED(
       LDAPResultCode.CLIENT_SIDE_USER_CANCELLED,
       INFO_RESULT_CLIENT_SIDE_USER_CANCELLED.get()),



  /**
   * The client-side result code that should be used if there was an
   * error in the parameter(s) provided.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_PARAM_ERROR(LDAPResultCode.CLIENT_SIDE_PARAM_ERROR,
                          INFO_RESULT_CLIENT_SIDE_PARAM_ERROR.get()),



  /**
   * The client-side result code that should be used if the client
   * cannot obtain enough memory to perform the requested operation.
   * This should not be used over protocol.
   */
  CLIENT_SIDE_NO_MEMORY(LDAPResultCode.CLIENT_SIDE_NO_MEMORY,
                        INFO_RESULT_CLIENT_SIDE_NO_MEMORY.get()),



  /**
   * The client-side result code that should be used if a connection
   * cannot be established.  This should not be used over protocol.
   */
  CLIENT_SIDE_CONNECT_ERROR(LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR,
                         INFO_RESULT_CLIENT_SIDE_CONNECT_ERROR.get()),



  /**
   * The client-side result code that should be used if a user
   * requests an unsupported operation.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_NOT_SUPPORTED(LDAPResultCode.CLIENT_SIDE_NOT_SUPPORTED,
                         INFO_RESULT_CLIENT_SIDE_NOT_SUPPORTED.get()),



  /**
   * The client-side result code that should be used if an expected
   * control is not found in a response.  This should not be used over
   * protocol.
   */
  CLIENT_SIDE_CONTROL_NOT_FOUND(
       LDAPResultCode.CLIENT_SIDE_CONTROL_NOT_FOUND,
       INFO_RESULT_CLIENT_SIDE_CONTROL_NOT_FOUND.get()),



  /**
   * The client-side result code that should be used if no results
   * were returned for a search operation that expected them.  This
   * should not be used over protocol.
   */
  CLIENT_SIDE_NO_RESULTS_RETURNED(
       LDAPResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED,
       INFO_RESULT_CLIENT_SIDE_NO_RESULTS_RETURNED.get()),



  /**
   * The client-side result code that should be used if there are more
   * results to be processed.  This should not be used over protocol.
   */
  CLIENT_SIDE_MORE_RESULTS_TO_RETURN(
       LDAPResultCode.CLIENT_SIDE_MORE_RESULTS_TO_RETURN,
       INFO_RESULT_CLIENT_SIDE_MORE_RESULTS_TO_RETURN.get()),



  /**
   * The client-side result code that should be used if a referral
   * loop is detected.  This should not be used over protocol.
   */
  CLIENT_SIDE_CLIENT_LOOP(LDAPResultCode.CLIENT_SIDE_CLIENT_LOOP,
                          INFO_RESULT_CLIENT_SIDE_CLIENT_LOOP.get()),



  /**
   * The client-side result code that should be used if the referral
   * hop limit was exceeded.  This should not be used over protocol.
   */
  CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED(
       LDAPResultCode.CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED,
       INFO_RESULT_CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED.get()),



  /**
   * The result code that indicates that a cancel request was
   * successful, or that the specified operation was canceled.
   */
  CANCELED(LDAPResultCode.CANCELED, INFO_RESULT_CANCELED.get()),



  /**
   * The result code that indicates that a cancel request was
   * unsuccessful because the targeted operation did not exist or had
   * already completed.
   */
  NO_SUCH_OPERATION(LDAPResultCode.NO_SUCH_OPERATION,
                    INFO_RESULT_NO_SUCH_OPERATION.get()),



  /**
   * The result code that indicates that a cancel request was
   * unsuccessful because processing on the targeted operation had
   * already reached a point at which it could not be canceled.
   */
  TOO_LATE(LDAPResultCode.TOO_LATE, INFO_RESULT_TOO_LATE.get()),



  /**
   * The result code that indicates that a cancel request was
   * unsuccessful because the targeted operation was one that could
   * not be canceled.
   */
  CANNOT_CANCEL(LDAPResultCode.CANNOT_CANCEL,
                INFO_RESULT_CANNOT_CANCEL.get()),



  /**
   * The result code that indicates that the filter contained in an
   * assertion control failed to match the target entry.
   */
  ASSERTION_FAILED(LDAPResultCode.ASSERTION_FAILED,
                   INFO_RESULT_ASSERTION_FAILED.get()),



  /**
   * The result code that should be used if the server will not allow
   * the client to use the requested authorization.
   */
  AUTHORIZATION_DENIED(LDAPResultCode.AUTHORIZATION_DENIED,
                       INFO_RESULT_AUTHORIZATION_DENIED.get()),



  /**
   * The result code that should be used if the server did not
   * actually complete processing on the associated operation because
   * the request included the LDAP No-Op control.
   */
  NO_OPERATION(LDAPResultCode.NO_OPERATION,
               INFO_RESULT_NO_OPERATION.get());



  // The integer value for this result code.
  private int intValue;

  // The short human-readable name for this result code.
  private Message resultCodeName;



  /**
   * Creates a new result code with the specified int value and unique
   * identifier.
   *
   * @param  intValue      The integer value for this result code.
   * @param  name          The name for this result code.
   */
  private ResultCode(int intValue, Message name)
  {
    Validator.ensureNotNull(name);
    this.intValue       = intValue;
    this.resultCodeName = name;
  }



  /**
   * Retrieves the integer value for this result code.
   *
   * @return  The integer value for this result code.
   */
  public int getIntValue()
  {
    return intValue;
  }



  /**
   * Retrieves the result code with the provided int value.
   *
   * @param  intValue  The value for which to retrieve the
   *                   corresponding result code.
   *
   * @return  The result code with the provided int value, or
   *          <CODE>ResultCode.OTHER</CODE> if there is no recognized
   *          result code with the provided int value.
   */
  public static ResultCode valueOf(int intValue)
  {
    switch (intValue)
    {
      case LDAPResultCode.SUCCESS:
        return SUCCESS;
      case LDAPResultCode.OPERATIONS_ERROR:
        return OPERATIONS_ERROR;
      case LDAPResultCode.PROTOCOL_ERROR:
        return PROTOCOL_ERROR;
      case LDAPResultCode.TIME_LIMIT_EXCEEDED:
        return TIME_LIMIT_EXCEEDED;
      case LDAPResultCode.SIZE_LIMIT_EXCEEDED:
        return SIZE_LIMIT_EXCEEDED;
      case LDAPResultCode.COMPARE_FALSE:
        return COMPARE_FALSE;
      case LDAPResultCode.COMPARE_TRUE:
        return COMPARE_TRUE;
      case LDAPResultCode.AUTH_METHOD_NOT_SUPPORTED:
        return AUTH_METHOD_NOT_SUPPORTED;
      case LDAPResultCode.STRONG_AUTH_REQUIRED:
        return STRONG_AUTH_REQUIRED;
      case LDAPResultCode.REFERRAL:
        return REFERRAL;
      case LDAPResultCode.ADMIN_LIMIT_EXCEEDED:
        return ADMIN_LIMIT_EXCEEDED;
      case LDAPResultCode.UNAVAILABLE_CRITICAL_EXTENSION:
        return UNAVAILABLE_CRITICAL_EXTENSION;
      case LDAPResultCode.CONFIDENTIALITY_REQUIRED:
        return CONFIDENTIALITY_REQUIRED;
      case LDAPResultCode.SASL_BIND_IN_PROGRESS:
        return SASL_BIND_IN_PROGRESS;
      case LDAPResultCode.NO_SUCH_ATTRIBUTE:
        return NO_SUCH_ATTRIBUTE;
      case LDAPResultCode.UNDEFINED_ATTRIBUTE_TYPE:
        return UNDEFINED_ATTRIBUTE_TYPE;
      case LDAPResultCode.INAPPROPRIATE_MATCHING:
        return INAPPROPRIATE_MATCHING;
      case LDAPResultCode.CONSTRAINT_VIOLATION:
        return CONSTRAINT_VIOLATION;
      case LDAPResultCode.ATTRIBUTE_OR_VALUE_EXISTS:
        return ATTRIBUTE_OR_VALUE_EXISTS;
      case LDAPResultCode.INVALID_ATTRIBUTE_SYNTAX:
        return INVALID_ATTRIBUTE_SYNTAX;
      case LDAPResultCode.NO_SUCH_OBJECT:
        return NO_SUCH_OBJECT;
      case LDAPResultCode.ALIAS_PROBLEM:
        return ALIAS_PROBLEM;
      case LDAPResultCode.INVALID_DN_SYNTAX:
        return INVALID_DN_SYNTAX;
      case LDAPResultCode.ALIAS_DEREFERENCING_PROBLEM:
        return ALIAS_DEREFERENCING_PROBLEM;
      case LDAPResultCode.INAPPROPRIATE_AUTHENTICATION:
        return INAPPROPRIATE_AUTHENTICATION;
      case LDAPResultCode.INVALID_CREDENTIALS:
        return INVALID_CREDENTIALS;
      case LDAPResultCode.INSUFFICIENT_ACCESS_RIGHTS:
        return INSUFFICIENT_ACCESS_RIGHTS;
      case LDAPResultCode.BUSY:
        return BUSY;
      case LDAPResultCode.UNAVAILABLE:
        return UNAVAILABLE;
      case LDAPResultCode.UNWILLING_TO_PERFORM:
        return UNWILLING_TO_PERFORM;
      case LDAPResultCode.LOOP_DETECT:
        return LOOP_DETECT;
      case LDAPResultCode.SORT_CONTROL_MISSING:
        return SORT_CONTROL_MISSING;
      case LDAPResultCode.OFFSET_RANGE_ERROR:
        return OFFSET_RANGE_ERROR;
      case LDAPResultCode.NAMING_VIOLATION:
        return NAMING_VIOLATION;
      case LDAPResultCode.OBJECTCLASS_VIOLATION:
        return OBJECTCLASS_VIOLATION;
      case LDAPResultCode.NOT_ALLOWED_ON_NONLEAF:
        return NOT_ALLOWED_ON_NONLEAF;
      case LDAPResultCode.NOT_ALLOWED_ON_RDN:
        return NOT_ALLOWED_ON_RDN;
      case LDAPResultCode.ENTRY_ALREADY_EXISTS:
        return ENTRY_ALREADY_EXISTS;
      case LDAPResultCode.OBJECTCLASS_MODS_PROHIBITED:
        return OBJECTCLASS_MODS_PROHIBITED;
      case LDAPResultCode.AFFECTS_MULTIPLE_DSAS:
        return AFFECTS_MULTIPLE_DSAS;
      case LDAPResultCode.VIRTUAL_LIST_VIEW_ERROR:
        return VIRTUAL_LIST_VIEW_ERROR;
      case LDAPResultCode.CLIENT_SIDE_SERVER_DOWN:
        return CLIENT_SIDE_SERVER_DOWN;
      case LDAPResultCode.CLIENT_SIDE_LOCAL_ERROR:
        return CLIENT_SIDE_LOCAL_ERROR;
      case LDAPResultCode.CLIENT_SIDE_ENCODING_ERROR:
        return CLIENT_SIDE_ENCODING_ERROR;
      case LDAPResultCode.CLIENT_SIDE_DECODING_ERROR:
        return CLIENT_SIDE_DECODING_ERROR;
      case LDAPResultCode.CLIENT_SIDE_TIMEOUT:
        return CLIENT_SIDE_TIMEOUT;
      case LDAPResultCode.CLIENT_SIDE_AUTH_UNKNOWN:
        return CLIENT_SIDE_AUTH_UNKNOWN;
      case LDAPResultCode.CLIENT_SIDE_FILTER_ERROR:
        return CLIENT_SIDE_FILTER_ERROR;
      case LDAPResultCode.CLIENT_SIDE_USER_CANCELLED:
        return CLIENT_SIDE_USER_CANCELLED;
      case LDAPResultCode.CLIENT_SIDE_PARAM_ERROR:
        return CLIENT_SIDE_PARAM_ERROR;
      case LDAPResultCode.CLIENT_SIDE_NO_MEMORY:
        return CLIENT_SIDE_NO_MEMORY;
      case LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR:
        return CLIENT_SIDE_CONNECT_ERROR;
      case LDAPResultCode.CLIENT_SIDE_NOT_SUPPORTED:
        return CLIENT_SIDE_NOT_SUPPORTED;
      case LDAPResultCode.CLIENT_SIDE_CONTROL_NOT_FOUND:
        return CLIENT_SIDE_CONTROL_NOT_FOUND;
      case LDAPResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED:
        return CLIENT_SIDE_NO_RESULTS_RETURNED;
      case LDAPResultCode.CLIENT_SIDE_MORE_RESULTS_TO_RETURN:
        return CLIENT_SIDE_MORE_RESULTS_TO_RETURN;
      case LDAPResultCode.CLIENT_SIDE_CLIENT_LOOP:
        return CLIENT_SIDE_CLIENT_LOOP;
      case LDAPResultCode.CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED:
        return CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED;
      case LDAPResultCode.CANCELED:
        return CANCELED;
      case LDAPResultCode.NO_SUCH_OPERATION:
        return NO_SUCH_OPERATION;
      case LDAPResultCode.TOO_LATE:
        return TOO_LATE;
      case LDAPResultCode.CANNOT_CANCEL:
        return CANNOT_CANCEL;
      case LDAPResultCode.ASSERTION_FAILED:
        return ASSERTION_FAILED;
      case LDAPResultCode.AUTHORIZATION_DENIED:
        return AUTHORIZATION_DENIED;
      case LDAPResultCode.NO_OPERATION:
        // FIXME -- We will also need to handle the official result
        //          code when it is allocated.
        return NO_OPERATION;
      default:
        return ResultCode.OTHER;
    }
  }



  /**
   * Retrieves the short human-readable name for this result code.
   *
   * @return  The short human-readable name for this result code.
   */
  public Message getResultCodeName()
  {
    return resultCodeName;
  }



  /**
   * Retrieves a string representation of this result code.
   *
   * @return  A string representation of this result code.
   */
  public String toString()
  {
    return resultCodeName.toString();
  }
}

