001    /*
002     * Copyright 2009-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2009-2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.protocol;
022    
023    
024    
025    import com.unboundid.asn1.ASN1Buffer;
026    import com.unboundid.asn1.ASN1BufferSequence;
027    import com.unboundid.asn1.ASN1Element;
028    import com.unboundid.asn1.ASN1OctetString;
029    import com.unboundid.asn1.ASN1Sequence;
030    import com.unboundid.asn1.ASN1StreamReader;
031    import com.unboundid.ldap.sdk.CompareRequest;
032    import com.unboundid.ldap.sdk.Control;
033    import com.unboundid.ldap.sdk.LDAPException;
034    import com.unboundid.ldap.sdk.ResultCode;
035    import com.unboundid.util.InternalUseOnly;
036    
037    import static com.unboundid.ldap.protocol.ProtocolMessages.*;
038    import static com.unboundid.util.Debug.*;
039    import static com.unboundid.util.StaticUtils.*;
040    import static com.unboundid.util.Validator.*;
041    
042    
043    
044    /**
045     * This class provides an implementation of an LDAP compare request protocol op.
046     */
047    @InternalUseOnly()
048    public final class CompareRequestProtocolOp
049           implements ProtocolOp
050    {
051      /**
052       * The serial version UID for this serializable class.
053       */
054      private static final long serialVersionUID = -562642367801440060L;
055    
056    
057    
058      // The assertion value for this compare request.
059      private final ASN1OctetString assertionValue;
060    
061      // The attribute name for this compare request.
062      private final String attributeName;
063    
064      // The entry DN for this compare request.
065      private final String dn;
066    
067    
068    
069      /**
070       * Creates a new compare request protocol op with the provided information.
071       *
072       * @param  dn              The DN for this compare request.
073       * @param  attributeName   The attribute name for this compare request.
074       * @param  assertionValue  The assertion value for this compare request.
075       */
076      public CompareRequestProtocolOp(final String dn, final String attributeName,
077                                      final ASN1OctetString assertionValue)
078      {
079        this.dn             = dn;
080        this.attributeName  = attributeName;
081        this.assertionValue = assertionValue;
082      }
083    
084    
085    
086      /**
087       * Creates a new compare request protocol op from the provided compare request
088       * object.
089       *
090       * @param  request  The compare request object to use to create this protocol
091       *                  op.
092       */
093      public CompareRequestProtocolOp(final CompareRequest request)
094      {
095        dn             = request.getDN();
096        attributeName  = request.getAttributeName();
097        assertionValue = request.getRawAssertionValue();
098      }
099    
100    
101    
102      /**
103       * Creates a new compare request protocol op read from the provided ASN.1
104       * stream reader.
105       *
106       * @param  reader  The ASN.1 stream reader from which to read the compare
107       *                 request protocol op.
108       *
109       * @throws  LDAPException  If a problem occurs while reading or parsing the
110       *                         compare request.
111       */
112      CompareRequestProtocolOp(final ASN1StreamReader reader)
113           throws LDAPException
114      {
115        try
116        {
117          reader.beginSequence();
118          dn = reader.readString();
119    
120          reader.beginSequence();
121          attributeName = reader.readString();
122          assertionValue = new ASN1OctetString(reader.readBytes());
123          ensureNotNull(dn, attributeName, assertionValue);
124        }
125        catch (Exception e)
126        {
127          debugException(e);
128    
129          throw new LDAPException(ResultCode.DECODING_ERROR,
130               ERR_COMPARE_REQUEST_CANNOT_DECODE.get(getExceptionMessage(e)), e);
131        }
132      }
133    
134    
135    
136      /**
137       * Retrieves the DN for this compare request.
138       *
139       * @return  The DN for this compare request.
140       */
141      public String getDN()
142      {
143        return dn;
144      }
145    
146    
147    
148      /**
149       * Retrieves the attribute name for this compare request.
150       *
151       * @return  The attribute name for this compare request.
152       */
153      public String getAttributeName()
154      {
155        return attributeName;
156      }
157    
158    
159    
160      /**
161       * Retrieves the assertion value for this compare request.
162       *
163       * @return  The assertion value for this compare request.
164       */
165      public ASN1OctetString getAssertionValue()
166      {
167        return assertionValue;
168      }
169    
170    
171    
172      /**
173       * {@inheritDoc}
174       */
175      public byte getProtocolOpType()
176      {
177        return LDAPMessage.PROTOCOL_OP_TYPE_COMPARE_REQUEST;
178      }
179    
180    
181    
182      /**
183       * {@inheritDoc}
184       */
185      public ASN1Element encodeProtocolOp()
186      {
187        return new ASN1Sequence(LDAPMessage.PROTOCOL_OP_TYPE_COMPARE_REQUEST,
188             new ASN1OctetString(dn),
189             new ASN1Sequence(
190                  new ASN1OctetString(attributeName),
191                  assertionValue));
192      }
193    
194    
195    
196      /**
197       * Decodes the provided ASN.1 element as a compare request protocol op.
198       *
199       * @param  element  The ASN.1 element to be decoded.
200       *
201       * @return  The decoded compare request protocol op.
202       *
203       * @throws  LDAPException  If the provided ASN.1 element cannot be decoded as
204       *                         a compare request protocol op.
205       */
206      public static CompareRequestProtocolOp decodeProtocolOp(
207                                                  final ASN1Element element)
208             throws LDAPException
209      {
210        try
211        {
212          final ASN1Element[] elements =
213               ASN1Sequence.decodeAsSequence(element).elements();
214          final String dn =
215               ASN1OctetString.decodeAsOctetString(elements[0]).stringValue();
216    
217          final ASN1Element[] avaElements =
218               ASN1Sequence.decodeAsSequence(elements[1]).elements();
219          final String attributeName =
220               ASN1OctetString.decodeAsOctetString(avaElements[0]).stringValue();
221          final ASN1OctetString assertionValue =
222               ASN1OctetString.decodeAsOctetString(avaElements[1]);
223    
224          return new CompareRequestProtocolOp(dn, attributeName, assertionValue);
225        }
226        catch (final Exception e)
227        {
228          debugException(e);
229          throw new LDAPException(ResultCode.DECODING_ERROR,
230               ERR_COMPARE_REQUEST_CANNOT_DECODE.get(getExceptionMessage(e)),
231               e);
232        }
233      }
234    
235    
236    
237      /**
238       * {@inheritDoc}
239       */
240      public void writeTo(final ASN1Buffer buffer)
241      {
242        final ASN1BufferSequence opSequence =
243             buffer.beginSequence(LDAPMessage.PROTOCOL_OP_TYPE_COMPARE_REQUEST);
244        buffer.addOctetString(dn);
245    
246        final ASN1BufferSequence avaSequence = buffer.beginSequence();
247        buffer.addOctetString(attributeName);
248        buffer.addElement(assertionValue);
249        avaSequence.end();
250        opSequence.end();
251      }
252    
253    
254    
255      /**
256       * Creates a compare request from this protocol op.
257       *
258       * @param  controls  The set of controls to include in the compare request.
259       *                   It may be empty or {@code null} if no controls should be
260       *                   included.
261       *
262       * @return  The compare request that was created.
263       */
264      public CompareRequest toCompareRequest(final Control... controls)
265      {
266        return new CompareRequest(dn, attributeName, assertionValue.getValue(),
267             controls);
268      }
269    
270    
271    
272      /**
273       * Retrieves a string representation of this protocol op.
274       *
275       * @return  A string representation of this protocol op.
276       */
277      @Override()
278      public String toString()
279      {
280        final StringBuilder buffer = new StringBuilder();
281        toString(buffer);
282        return buffer.toString();
283      }
284    
285    
286    
287      /**
288       * {@inheritDoc}
289       */
290      public void toString(final StringBuilder buffer)
291      {
292        buffer.append("CompareRequestProtocolOp(dn='");
293        buffer.append(dn);
294        buffer.append("', attributeName='");
295        buffer.append(attributeName);
296        buffer.append("', assertionValue='");
297        buffer.append(assertionValue.stringValue());
298        buffer.append("')");
299      }
300    }