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.ldap.sdk; 022 023 024 025 import java.io.Serializable; 026 import java.util.HashMap; 027 028 029 030 031 /** 032 * This class defines a data type for modification type values. Clients should 033 * generally use one of the {@code ADD}, {@code DELETE}, {@code REPLACE}, or 034 * {@code INCREMENT} values, although it is possible to create a new 035 * modification type with a specified integer value if necessary using the 036 * {@code valueOf(int)} method. The following modification types are defined: 037 * <UL> 038 * <LI>{@code ADD} -- Indicates that the provided value(s) should be added to 039 * the specified attribute in the target entry. If the attribute does not 040 * already exist, it will be created. If it does exist, then the new 041 * values will be merged added to the existing values. At least one value 042 * must be provided with the {@code ADD} modification type, and none of 043 * those values will be allowed to exist in the entry.</LI> 044 * <LI>{@code DELETE} -- Indicates that the specified attribute or attribute 045 * values should be removed from the entry. If no values are provided, 046 * then the entire attribute will be removed. If one or more values are 047 * given, then only those values will be removed. If any values are 048 * provided, then all of those values must exist in the target entry.</LI> 049 * <LI>{@code REPLACE} -- Indicates that the set of values for the specified 050 * attribute should be replaced with the provided value(s). If no values 051 * are given, then the specified attribute will be removed from the entry 052 * if it exists, or no change will be made. If one or more values are 053 * provided, then those values will replace the existing values if the 054 * attribute already exists, or a new attribute will be added with those 055 * values if there was previously no such attribute in the entry.</LI> 056 * <LI>{@code INCREMENT} -- Indicates that the value of the specified 057 * attribute should be incremented. The target entry must have exactly 058 * one value for the specified attribute and it must be an integer. The 059 * modification must include exactly one value, and it must be an integer 060 * which specifies the amount by which the existing value is to be 061 * incremented (or decremented, if the provided value is negative).</LI> 062 * </UL> 063 */ 064 public final class ModificationType 065 implements Serializable 066 { 067 /** 068 * The integer value for the "add" modification type. 069 */ 070 public static final int ADD_INT_VALUE = 0; 071 072 073 074 /** 075 * A predefined add modification type, which indicates that the associated 076 * value(s) should be added to the specified attribute in the target entry. 077 * If the attribute does not already exist, it will be created. If it does 078 * exist, then the new values will be merged added to the existing values. At 079 * least one value must be provided with the {@code ADD} modification type, 080 * and none of those values will be allowed to exist in the entry. 081 */ 082 public static final ModificationType ADD = 083 new ModificationType("ADD", ADD_INT_VALUE); 084 085 086 087 /** 088 * The integer value for the "delete" modification type. 089 */ 090 public static final int DELETE_INT_VALUE = 1; 091 092 093 094 /** 095 * A predefined delete modification type, which indicates that the specified 096 * attribute or attribute values should be removed from the entry. If no 097 * values are provided, then the entire attribute will be removed. If one or 098 * more values are given, then only those values will be removed. If any 099 * values are provided, then all of those values must exist in the target 100 * entry. 101 */ 102 public static final ModificationType DELETE = 103 new ModificationType("DELETE", DELETE_INT_VALUE); 104 105 106 107 /** 108 * The integer value for the "replace" modification type. 109 */ 110 public static final int REPLACE_INT_VALUE = 2; 111 112 113 114 /** 115 * A predefined replace modification type, which indicates that the set of 116 * values for the specified attribute should be replaced with the provided 117 * value(s). If no values are given, then the specified attribute will be 118 * removed from the entry if it exists, or no change will be made. If one or 119 * more values are provided, then those values will replace the existing 120 * values if the attribute already exists, or a new attribute will be added 121 * with those values if there was previously no such attribute in the entry. 122 */ 123 public static final ModificationType REPLACE = 124 new ModificationType("REPLACE", REPLACE_INT_VALUE); 125 126 127 128 /** 129 * The integer value for the "increment" modification type. 130 */ 131 public static final int INCREMENT_INT_VALUE = 3; 132 133 134 135 /** 136 * A predefined increment modification type, which indicates that the value of 137 * the specified attribute should be incremented. The target entry must have 138 * exactly one value for the specified attribute and it must be an integer. 139 * The modification must include exactly one value, and it must be an integer 140 * which specifies the amount by which the existing value is to be incremented 141 * (or decremented, if the provided value is negative). 142 */ 143 public static final ModificationType INCREMENT = 144 new ModificationType("INCREMENT", INCREMENT_INT_VALUE); 145 146 147 148 /** 149 * The set of result code objects created with undefined int result code 150 * values. 151 */ 152 private static final HashMap<Integer,ModificationType> UNDEFINED_MOD_TYPES = 153 new HashMap<Integer,ModificationType>(); 154 155 156 157 /** 158 * The serial version UID for this serializable class. 159 */ 160 private static final long serialVersionUID = -7863114394728980308L; 161 162 163 164 // The integer value for this modification type. 165 private final int intValue; 166 167 // The name to use for this modification type. 168 private final String name; 169 170 171 172 /** 173 * Creates a new modification type with the specified integer value. 174 * 175 * @param intValue The integer value to use for this modification type. 176 */ 177 private ModificationType(final int intValue) 178 { 179 this.intValue = intValue; 180 181 name = String.valueOf(intValue); 182 } 183 184 185 186 /** 187 * Creates a new modification type with the specified name and integer value. 188 * 189 * @param name The name to use for this modification type. 190 * @param intValue The integer value to use for this modification type. 191 */ 192 private ModificationType(final String name, final int intValue) 193 { 194 this.name = name; 195 this.intValue = intValue; 196 } 197 198 199 200 /** 201 * Retrieves the name for this modification type. 202 * 203 * @return The name for this modification type. 204 */ 205 public String getName() 206 { 207 return name; 208 } 209 210 211 212 /** 213 * Retrieves the integer value for this modification type. 214 * 215 * @return The integer value for this modification type. 216 */ 217 public int intValue() 218 { 219 return intValue; 220 } 221 222 223 224 /** 225 * Retrieves the modification type with the specified integer value. 226 * 227 * @param intValue The integer value for which to retrieve the corresponding 228 * modification type. 229 * 230 * @return The modification type with the specified integer value, or a new 231 * modification type if the provided value does not match any of the 232 * predefined modification types. 233 */ 234 public static ModificationType valueOf(final int intValue) 235 { 236 switch (intValue) 237 { 238 case 0: 239 return ADD; 240 case 1: 241 return DELETE; 242 case 2: 243 return REPLACE; 244 case 3: 245 return INCREMENT; 246 default: 247 synchronized (UNDEFINED_MOD_TYPES) 248 { 249 ModificationType t = UNDEFINED_MOD_TYPES.get(intValue); 250 if (t == null) 251 { 252 t = new ModificationType(intValue); 253 UNDEFINED_MOD_TYPES.put(intValue, t); 254 } 255 256 return t; 257 } 258 } 259 } 260 261 262 263 /** 264 * Retrieves the predefined modification type with the specified integer 265 * value. 266 * 267 * @param intValue The integer value for which to retrieve the corresponding 268 * modification type. 269 * 270 * @return The modification type with the specified integer value, or 271 * {@code null} if the provided integer value does not represent a 272 * defined modification type. 273 */ 274 public static ModificationType definedValueOf(final int intValue) 275 { 276 switch (intValue) 277 { 278 case 0: 279 return ADD; 280 case 1: 281 return DELETE; 282 case 2: 283 return REPLACE; 284 case 3: 285 return INCREMENT; 286 default: 287 return null; 288 } 289 } 290 291 292 293 /** 294 * Retrieves an array of all modification types defined in the LDAP SDK. 295 * 296 * @return An array of all modification types defined in the LDAP SDK. 297 */ 298 public static ModificationType[] values() 299 { 300 return new ModificationType[] 301 { 302 ADD, 303 DELETE, 304 REPLACE, 305 INCREMENT 306 }; 307 } 308 309 310 311 /** 312 * The hash code for this modification type. 313 * 314 * @return The hash code for this modification type. 315 */ 316 @Override() 317 public int hashCode() 318 { 319 return intValue; 320 } 321 322 323 324 /** 325 * Indicates whether the provided object is equal to this modification type. 326 * 327 * @param o The object for which to make the determination. 328 * 329 * @return {@code true} if the provided object is a modification type that is 330 * equal to this modification type, or {@code false} if not. 331 */ 332 @Override() 333 public boolean equals(final Object o) 334 { 335 if (o == null) 336 { 337 return false; 338 } 339 else if (o == this) 340 { 341 return true; 342 } 343 else if (o instanceof ModificationType) 344 { 345 return (intValue == ((ModificationType) o).intValue); 346 } 347 else 348 { 349 return false; 350 } 351 } 352 353 354 355 /** 356 * Retrieves a string representation of this modification type. 357 * 358 * @return A string representation of this modification type. 359 */ 360 @Override() 361 public String toString() 362 { 363 return name; 364 } 365 }