• Home
• com.unboundid
• unboundid-ldapsdk-commercial-edition
• 3.1.1
• source code
• HardDeleteRequestControl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.unboundid.ldap.sdk.unboundidds.controls.HardDeleteRequestControl Maven / Gradle / Ivy

/*
 * Copyright 2012-2016 UnboundID Corp.
 * All Rights Reserved.
 */
/*
 * Copyright (C) 2015-2016 UnboundID Corp.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (GPLv2 only)
 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see .
 */
package com.unboundid.ldap.sdk.unboundidds.controls;



import com.unboundid.asn1.ASN1Element;
import com.unboundid.asn1.ASN1Sequence;
import com.unboundid.ldap.sdk.Control;
import com.unboundid.ldap.sdk.DeleteRequest;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.util.Debug;
import com.unboundid.util.NotMutable;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;

import static com.unboundid.ldap.sdk.unboundidds.controls.ControlMessages.*;



/**
 * 

 *   NOTE:  This class is part of the Commercial Edition of the UnboundID
 *   LDAP SDK for Java.  It is not available for use in applications that
 *   include only the Standard Edition of the LDAP SDK, and is not supported for
 *   use in conjunction with non-UnboundID products.
 * 
 * This class provides a request control which may be included in a delete
 * request to indicate that the server should completely remove the target
 * entry, even if it would otherwise process the operation as a soft delete and
 * merely hide the entry from most clients.
 * 


 * The criticality for this control may be either {@code TRUE} or {@code FALSE},
 * but this will only impact how the delete request is to be handled by servers
 * which do not support this control.  A criticality of {@code TRUE} will cause
 * any server which does not support this control to reject the request, while
 * a criticality of {@code FALSE} should cause the delete request to be
 * processed as if the control had not been included (i.e., as a regular "hard"
 * delete).
 * 


 * The control may optionally have a value.  If a value is provided, then it
 * must be the encoded representation of an empty ASN.1 sequence, like:
 * 
 *   HardDeleteRequestValue ::= SEQUENCE {
 *     ... }
 * 
 * In the future, the value sequence may allow one or more elements to customize
 * the behavior of the hard delete operation, but at present no such elements
 * are defined.
 * See the documentation for the {@link SoftDeleteRequestControl} class for an
 * example demonstrating the use of this control.
 *
 * @see  SoftDeleteRequestControl
 */
@NotMutable()
@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
public final class HardDeleteRequestControl
       extends Control
{
  /**
   * The OID (1.3.6.1.4.1.30221.2.5.22) for the hard delete request control.
   */
  public static final String HARD_DELETE_REQUEST_OID =
       "1.3.6.1.4.1.30221.2.5.22";



  /**
   * The serial version UID for this serializable class.
   */
  private static final long serialVersionUID = 1169625153021056712L;



  /**
   * Creates a new hard delete request control.  It will not be marked critical.
   */
  public HardDeleteRequestControl()
  {
    this(false);
  }



  /**
   * Creates a new hard delete request control with the provided information.
   *
   * @param  isCritical  Indicates whether this control should be marked
   *                     critical.  This will only have an effect on the way the
   *                     associated delete operation is handled by servers which
   *                     do NOT support the hard delete request control.  For
   *                     such servers, a control that is critical will cause the
   *                     hard delete attempt to fail, while a control that is
   *                     not critical will be processed as if the control was
   *                     not included in the request (i.e., as a normal "hard"
   *                     delete).
   */
  public HardDeleteRequestControl(final boolean isCritical)
  {
    super(HARD_DELETE_REQUEST_OID, isCritical, null);
  }



  /**
   * Creates a new hard delete request control which is decoded from the
   * provided generic control.
   *
   * @param  control  The generic control to be decoded as a hard delete request
   *                  control.
   *
   * @throws  LDAPException  If the provided control cannot be decoded as a hard
   *                         delete request control.
   */
  public HardDeleteRequestControl(final Control control)
         throws LDAPException
  {
    super(control);

    if (control.hasValue())
    {
      try
      {
        final ASN1Sequence valueSequence =
             ASN1Sequence.decodeAsSequence(control.getValue().getValue());
        final ASN1Element[] elements = valueSequence.elements();
        if (elements.length > 0)
        {
          throw new LDAPException(ResultCode.DECODING_ERROR,
               ERR_HARD_DELETE_REQUEST_UNSUPPORTED_VALUE_ELEMENT_TYPE.get(
                    StaticUtils.toHex(elements[0].getType())));
        }
      }
      catch (final LDAPException le)
      {
        Debug.debugException(le);
        throw le;
      }
      catch (final Exception e)
      {
        Debug.debugException(e);
        throw new LDAPException(ResultCode.DECODING_ERROR,
             ERR_HARD_DELETE_REQUEST_CANNOT_DECODE_VALUE.get(
                  StaticUtils.getExceptionMessage(e)),
             e);
      }
    }
  }



  /**
   * Creates a new delete request that may be used to hard delete the specified
   * target entry.
   *
   * @param  targetDN    The DN of the entry to be hard deleted.
   * @param  isCritical  Indicates whether this control should be marked
   *                     critical.  This will only have an effect on the way the
   *                     associated delete operation is handled by servers which
   *                     do NOT support the hard delete request control.  For
   *                     such servers, a control that is critical will cause the
   *                     hard delete attempt to fail, while a control that is
   *                     not critical will be processed as if the control was
   *                     not included in the request (i.e., as a normal "hard"
   *                     delete).
   *
   * @return  A delete request with the specified target DN and an appropriate
   *          hard delete request control.
   */
  public static DeleteRequest createHardDeleteRequest(final String targetDN,
                                                      final boolean isCritical)
  {
    final Control[] controls =
    {
      new HardDeleteRequestControl(isCritical)
    };

    return new DeleteRequest(targetDN, controls);
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public String getControlName()
  {
    return INFO_CONTROL_NAME_HARD_DELETE_REQUEST.get();
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public void toString(final StringBuilder buffer)
  {
    buffer.append("HardDeleteRequestControl(isCritical=");
    buffer.append(isCritical());
    buffer.append(')');
  }
}