001 /*
002 * Copyright 2007-2014 UnboundID Corp.
003 * All Rights Reserved.
004 */
005 /*
006 * Copyright (C) 2008-2014 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.ldif;
022
023
024
025 import java.util.ArrayList;
026 import java.util.HashSet;
027 import java.util.Iterator;
028 import java.util.List;
029
030 import com.unboundid.asn1.ASN1OctetString;
031 import com.unboundid.ldap.sdk.ChangeType;
032 import com.unboundid.ldap.sdk.Control;
033 import com.unboundid.ldap.sdk.LDAPException;
034 import com.unboundid.ldap.sdk.LDAPInterface;
035 import com.unboundid.ldap.sdk.LDAPResult;
036 import com.unboundid.ldap.sdk.Modification;
037 import com.unboundid.ldap.sdk.ModifyRequest;
038 import com.unboundid.util.ByteStringBuffer;
039
040 import static com.unboundid.util.Debug.*;
041 import static com.unboundid.util.StaticUtils.*;
042 import static com.unboundid.util.Validator.*;
043
044
045
046 /**
047 * This class defines an LDIF modify change record, which can be used to
048 * represent an LDAP modify request. See the documentation for the
049 * {@code LDIFChangeRecord} class for an example demonstrating the process for
050 * interacting with LDIF change records.
051 */
052 public final class LDIFModifyChangeRecord
053 extends LDIFChangeRecord
054 {
055 /**
056 * The name of the system property that will be used to indicate whether
057 * to always include a trailing dash after the last change in the LDIF
058 * representation of a modify change record. By default, the dash will always
059 * be included.
060 */
061 public static final String PROPERTY_ALWAYS_INCLUDE_TRAILING_DASH =
062 "com.unboundid.ldif.modify.alwaysIncludeTrailingDash";
063
064
065
066 /**
067 * Indicates whether to always include a trailing dash after the last change
068 * in the LDIF representation.
069 */
070 private static boolean alwaysIncludeTrailingDash = true;
071
072
073
074 static
075 {
076 final String propValue =
077 System.getProperty(PROPERTY_ALWAYS_INCLUDE_TRAILING_DASH);
078 if ((propValue != null) && (propValue.equalsIgnoreCase("false")))
079 {
080 alwaysIncludeTrailingDash = false;
081 }
082 }
083
084
085
086 /**
087 * The serial version UID for this serializable class.
088 */
089 private static final long serialVersionUID = -7558098319600288036L;
090
091
092
093 // The set of modifications for this modify change record.
094 private final Modification[] modifications;
095
096
097
098 /**
099 * Creates a new LDIF modify change record with the provided DN and set of
100 * modifications.
101 *
102 * @param dn The DN for this LDIF add change record. It must not
103 * be {@code null}.
104 * @param modifications The set of modifications for this LDIF modify change
105 * record. It must not be {@code null} or empty.
106 */
107 public LDIFModifyChangeRecord(final String dn,
108 final Modification... modifications)
109 {
110 this(dn, modifications, null);
111 }
112
113
114
115 /**
116 * Creates a new LDIF modify change record with the provided DN and set of
117 * modifications.
118 *
119 * @param dn The DN for this LDIF add change record. It must not
120 * be {@code null}.
121 * @param modifications The set of modifications for this LDIF modify change
122 * record. It must not be {@code null} or empty.
123 * @param controls The set of controls for this LDIF modify change
124 * record. It may be {@code null} or empty if there
125 * are no controls.
126 */
127 public LDIFModifyChangeRecord(final String dn,
128 final Modification[] modifications,
129 final List<Control> controls)
130 {
131 super(dn, controls);
132
133 ensureNotNull(modifications);
134 ensureTrue(modifications.length > 0,
135 "LDIFModifyChangeRecord.modifications must not be empty.");
136
137 this.modifications = modifications;
138 }
139
140
141
142 /**
143 * Creates a new LDIF modify change record with the provided DN and set of
144 * modifications.
145 *
146 * @param dn The DN for this LDIF add change record. It must not
147 * be {@code null}.
148 * @param modifications The set of modifications for this LDIF modify change
149 * record. It must not be {@code null} or empty.
150 */
151 public LDIFModifyChangeRecord(final String dn,
152 final List<Modification> modifications)
153 {
154 this(dn, modifications, null);
155 }
156
157
158
159 /**
160 * Creates a new LDIF modify change record with the provided DN and set of
161 * modifications.
162 *
163 * @param dn The DN for this LDIF add change record. It must not
164 * be {@code null}.
165 * @param modifications The set of modifications for this LDIF modify change
166 * record. It must not be {@code null} or empty.
167 * @param controls The set of controls for this LDIF modify change
168 * record. It may be {@code null} or empty if there
169 * are no controls.
170 */
171 public LDIFModifyChangeRecord(final String dn,
172 final List<Modification> modifications,
173 final List<Control> controls)
174 {
175 super(dn, controls);
176
177 ensureNotNull(modifications);
178 ensureFalse(modifications.isEmpty(),
179 "LDIFModifyChangeRecord.modifications must not be empty.");
180
181 this.modifications = new Modification[modifications.size()];
182 modifications.toArray(this.modifications);
183 }
184
185
186
187 /**
188 * Creates a new LDIF modify change record from the provided modify request.
189 *
190 * @param modifyRequest The modify request to use to create this LDIF modify
191 * change record. It must not be {@code null}.
192 */
193 public LDIFModifyChangeRecord(final ModifyRequest modifyRequest)
194 {
195 super(modifyRequest.getDN(), modifyRequest.getControlList());
196
197 final List<Modification> mods = modifyRequest.getModifications();
198 modifications = new Modification[mods.size()];
199
200 final Iterator<Modification> iterator = mods.iterator();
201 for (int i=0; i < modifications.length; i++)
202 {
203 modifications[i] = iterator.next();
204 }
205 }
206
207
208
209 /**
210 * Indicates whether the LDIF representation of a modify change record should
211 * always include a trailing dash after the last (or only) change.
212 *
213 * @return {@code true} if the LDIF representation of a modify change record
214 * should always include a trailing dash after the last (or only)
215 * change, or {@code false} if not.
216 */
217 public static boolean alwaysIncludeTrailingDash()
218 {
219 return alwaysIncludeTrailingDash;
220 }
221
222
223
224 /**
225 * Specifies whether the LDIF representation of a modify change record should
226 * always include a trailing dash after the last (or only) change.
227 *
228 * @param alwaysIncludeTrailingDash Indicates whether the LDIF
229 * representation of a modify change record
230 * should always include a trailing dash
231 * after the last (or only) change.
232 */
233 public static void setAlwaysIncludeTrailingDash(
234 final boolean alwaysIncludeTrailingDash)
235 {
236 LDIFModifyChangeRecord.alwaysIncludeTrailingDash =
237 alwaysIncludeTrailingDash;
238 }
239
240
241
242 /**
243 * Retrieves the set of modifications for this modify change record.
244 *
245 * @return The set of modifications for this modify change record.
246 */
247 public Modification[] getModifications()
248 {
249 return modifications;
250 }
251
252
253
254 /**
255 * Creates a modify request from this LDIF modify change record. Any change
256 * record controls will be included in the request
257 *
258 * @return The modify request created from this LDIF modify change record.
259 */
260 public ModifyRequest toModifyRequest()
261 {
262 return toModifyRequest(true);
263 }
264
265
266
267 /**
268 * Creates a modify request from this LDIF modify change record, optionally
269 * including any change record controls in the request.
270 *
271 * @param includeControls Indicates whether to include any controls in the
272 * request.
273 *
274 * @return The modify request created from this LDIF modify change record.
275 */
276 public ModifyRequest toModifyRequest(final boolean includeControls)
277 {
278 final ModifyRequest modifyRequest =
279 new ModifyRequest(getDN(), modifications);
280 if (includeControls)
281 {
282 modifyRequest.setControls(getControls());
283 }
284
285 return modifyRequest;
286 }
287
288
289
290 /**
291 * {@inheritDoc}
292 */
293 @Override()
294 public ChangeType getChangeType()
295 {
296 return ChangeType.MODIFY;
297 }
298
299
300
301 /**
302 * {@inheritDoc}
303 */
304 @Override()
305 public LDAPResult processChange(final LDAPInterface connection,
306 final boolean includeControls)
307 throws LDAPException
308 {
309 return connection.modify(toModifyRequest(includeControls));
310 }
311
312
313
314 /**
315 * {@inheritDoc}
316 */
317 @Override()
318 public String[] toLDIF(final int wrapColumn)
319 {
320 List<String> ldifLines = new ArrayList<String>(modifications.length*4);
321
322 ldifLines.add(LDIFWriter.encodeNameAndValue("dn",
323 new ASN1OctetString(getDN())));
324
325 for (final Control c : getControls())
326 {
327 ldifLines.add(LDIFWriter.encodeNameAndValue("control",
328 encodeControlString(c)));
329 }
330
331 ldifLines.add("changetype: modify");
332
333 for (int i=0; i < modifications.length; i++)
334 {
335 final String attrName = modifications[i].getAttributeName();
336
337 switch (modifications[i].getModificationType().intValue())
338 {
339 case 0:
340 ldifLines.add("add: " + attrName);
341 break;
342 case 1:
343 ldifLines.add("delete: " + attrName);
344 break;
345 case 2:
346 ldifLines.add("replace: " + attrName);
347 break;
348 case 3:
349 ldifLines.add("increment: " + attrName);
350 break;
351 default:
352 // This should never happen.
353 continue;
354 }
355
356 for (final ASN1OctetString value : modifications[i].getRawValues())
357 {
358 ldifLines.add(LDIFWriter.encodeNameAndValue(attrName, value));
359 }
360
361 if (alwaysIncludeTrailingDash || (i < (modifications.length - 1)))
362 {
363 ldifLines.add("-");
364 }
365 }
366
367 if (wrapColumn > 2)
368 {
369 ldifLines = LDIFWriter.wrapLines(wrapColumn, ldifLines);
370 }
371
372 final String[] ldifArray = new String[ldifLines.size()];
373 ldifLines.toArray(ldifArray);
374 return ldifArray;
375 }
376
377
378
379 /**
380 * {@inheritDoc}
381 */
382 @Override()
383 public void toLDIF(final ByteStringBuffer buffer, final int wrapColumn)
384 {
385 LDIFWriter.encodeNameAndValue("dn", new ASN1OctetString(getDN()), buffer,
386 wrapColumn);
387 buffer.append(EOL_BYTES);
388
389 for (final Control c : getControls())
390 {
391 LDIFWriter.encodeNameAndValue("control", encodeControlString(c), buffer,
392 wrapColumn);
393 buffer.append(EOL_BYTES);
394 }
395
396 LDIFWriter.encodeNameAndValue("changetype", new ASN1OctetString("modify"),
397 buffer, wrapColumn);
398 buffer.append(EOL_BYTES);
399
400 for (int i=0; i < modifications.length; i++)
401 {
402 final String attrName = modifications[i].getAttributeName();
403
404 switch (modifications[i].getModificationType().intValue())
405 {
406 case 0:
407 LDIFWriter.encodeNameAndValue("add", new ASN1OctetString(attrName),
408 buffer, wrapColumn);
409 buffer.append(EOL_BYTES);
410 break;
411 case 1:
412 LDIFWriter.encodeNameAndValue("delete", new ASN1OctetString(attrName),
413 buffer, wrapColumn);
414 buffer.append(EOL_BYTES);
415 break;
416 case 2:
417 LDIFWriter.encodeNameAndValue("replace",
418 new ASN1OctetString(attrName), buffer,
419 wrapColumn);
420 buffer.append(EOL_BYTES);
421 break;
422 case 3:
423 LDIFWriter.encodeNameAndValue("increment",
424 new ASN1OctetString(attrName), buffer,
425 wrapColumn);
426 buffer.append(EOL_BYTES);
427 break;
428 default:
429 // This should never happen.
430 continue;
431 }
432
433 for (final ASN1OctetString value : modifications[i].getRawValues())
434 {
435 LDIFWriter.encodeNameAndValue(attrName, value, buffer, wrapColumn);
436 buffer.append(EOL_BYTES);
437 }
438
439 if (alwaysIncludeTrailingDash || (i < (modifications.length - 1)))
440 {
441 buffer.append('-');
442 buffer.append(EOL_BYTES);
443 }
444 }
445 }
446
447
448
449 /**
450 * {@inheritDoc}
451 */
452 @Override()
453 public void toLDIFString(final StringBuilder buffer, final int wrapColumn)
454 {
455 LDIFWriter.encodeNameAndValue("dn", new ASN1OctetString(getDN()), buffer,
456 wrapColumn);
457 buffer.append(EOL);
458
459 for (final Control c : getControls())
460 {
461 LDIFWriter.encodeNameAndValue("control", encodeControlString(c), buffer,
462 wrapColumn);
463 buffer.append(EOL);
464 }
465
466 LDIFWriter.encodeNameAndValue("changetype", new ASN1OctetString("modify"),
467 buffer, wrapColumn);
468 buffer.append(EOL);
469
470 for (int i=0; i < modifications.length; i++)
471 {
472 final String attrName = modifications[i].getAttributeName();
473
474 switch (modifications[i].getModificationType().intValue())
475 {
476 case 0:
477 LDIFWriter.encodeNameAndValue("add", new ASN1OctetString(attrName),
478 buffer, wrapColumn);
479 buffer.append(EOL);
480 break;
481 case 1:
482 LDIFWriter.encodeNameAndValue("delete", new ASN1OctetString(attrName),
483 buffer, wrapColumn);
484 buffer.append(EOL);
485 break;
486 case 2:
487 LDIFWriter.encodeNameAndValue("replace",
488 new ASN1OctetString(attrName), buffer,
489 wrapColumn);
490 buffer.append(EOL);
491 break;
492 case 3:
493 LDIFWriter.encodeNameAndValue("increment",
494 new ASN1OctetString(attrName), buffer,
495 wrapColumn);
496 buffer.append(EOL);
497 break;
498 default:
499 // This should never happen.
500 continue;
501 }
502
503 for (final ASN1OctetString value : modifications[i].getRawValues())
504 {
505 LDIFWriter.encodeNameAndValue(attrName, value, buffer, wrapColumn);
506 buffer.append(EOL);
507 }
508
509 if (alwaysIncludeTrailingDash || (i < (modifications.length - 1)))
510 {
511 buffer.append('-');
512 buffer.append(EOL);
513 }
514 }
515 }
516
517
518
519 /**
520 * {@inheritDoc}
521 */
522 @Override()
523 public int hashCode()
524 {
525 int hashCode;
526 try
527 {
528 hashCode = getParsedDN().hashCode();
529 }
530 catch (final Exception e)
531 {
532 debugException(e);
533 hashCode = toLowerCase(getDN()).hashCode();
534 }
535
536 for (final Modification m : modifications)
537 {
538 hashCode += m.hashCode();
539 }
540
541 return hashCode;
542 }
543
544
545
546 /**
547 * {@inheritDoc}
548 */
549 @Override()
550 public boolean equals(final Object o)
551 {
552 if (o == null)
553 {
554 return false;
555 }
556
557 if (o == this)
558 {
559 return true;
560 }
561
562 if (! (o instanceof LDIFModifyChangeRecord))
563 {
564 return false;
565 }
566
567 final LDIFModifyChangeRecord r = (LDIFModifyChangeRecord) o;
568
569 final HashSet<Control> c1 = new HashSet<Control>(getControls());
570 final HashSet<Control> c2 = new HashSet<Control>(r.getControls());
571 if (! c1.equals(c2))
572 {
573 return false;
574 }
575
576 try
577 {
578 if (! getParsedDN().equals(r.getParsedDN()))
579 {
580 return false;
581 }
582 }
583 catch (final Exception e)
584 {
585 debugException(e);
586 if (! toLowerCase(getDN()).equals(toLowerCase(r.getDN())))
587 {
588 return false;
589 }
590 }
591
592 if (modifications.length != r.modifications.length)
593 {
594 return false;
595 }
596
597 for (int i=0; i < modifications.length; i++)
598 {
599 if (! modifications[i].equals(r.modifications[i]))
600 {
601 return false;
602 }
603 }
604
605 return true;
606 }
607
608
609
610 /**
611 * {@inheritDoc}
612 */
613 @Override()
614 public void toString(final StringBuilder buffer)
615 {
616 buffer.append("LDIFModifyChangeRecord(dn='");
617 buffer.append(getDN());
618 buffer.append("', mods={");
619
620 for (int i=0; i < modifications.length; i++)
621 {
622 if (i > 0)
623 {
624 buffer.append(", ");
625 }
626 modifications[i].toString(buffer);
627 }
628 buffer.append('}');
629
630 final List<Control> controls = getControls();
631 if (! controls.isEmpty())
632 {
633 buffer.append(", controls={");
634
635 final Iterator<Control> iterator = controls.iterator();
636 while (iterator.hasNext())
637 {
638 iterator.next().toString(buffer);
639 if (iterator.hasNext())
640 {
641 buffer.append(',');
642 }
643 }
644
645 buffer.append('}');
646 }
647
648 buffer.append(')');
649 }
650 }