001/*
002 * Copyright 2007-2017 UnboundID Corp.
003 * All Rights Reserved.
004 */
005/*
006 * Copyright (C) 2008-2017 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 */
021package com.unboundid.ldap.sdk;
022
023
024
025import java.io.Serializable;
026import java.util.concurrent.ConcurrentHashMap;
027
028import com.unboundid.util.NotMutable;
029import com.unboundid.util.ThreadSafety;
030import com.unboundid.util.ThreadSafetyLevel;
031
032import static com.unboundid.ldap.sdk.LDAPMessages.*;
033
034
035
036/**
037 * This class defines a number of constants associated with LDAP result codes.
038 * The {@code ResultCode} constant values defined in this class are immutable,
039 * and at most one result code object will ever be created for a given int
040 * value, so it is acceptable to compare result codes with either the
041 * {@link ResultCode#equals} method or the "{@code ==}" operator.
042 *<BR><BR>
043 * The result codes that are currently defined include:
044 * <BR>
045 * <CENTER>
046 *   <TABLE BORDER="1" CELLPADDING="3" CELLSPACING="0" WIDTH="50%"
047 *          SUMMARY="Result Code Names and Numeric Values">
048 *     <TR>
049 *       <TH ALIGN="LEFT">Name</TH>
050 *       <TH ALIGN="RIGHT">Integer Value</TH>
051 *     </TR>
052 *     <TR>
053 *       <TD ALIGN="LEFT">SUCCESS</TD>
054 *       <TD ALIGN="RIGHT">0</TD>
055 *     </TR>
056 *     <TR>
057 *       <TD ALIGN="LEFT">OPERATIONS_ERROR</TD>
058 *       <TD ALIGN="RIGHT">1</TD>
059 *     </TR>
060 *     <TR>
061 *       <TD ALIGN="LEFT">PROTOCOL_ERROR</TD>
062 *       <TD ALIGN="RIGHT">2</TD>
063 *     </TR>
064 *     <TR>
065 *       <TD ALIGN="LEFT">TIME_LIMIT_EXCEEDED</TD>
066 *       <TD ALIGN="RIGHT">3</TD>
067 *     </TR>
068 *     <TR>
069 *       <TD ALIGN="LEFT">SIZE_LIMIT_EXCEEDED</TD>
070 *       <TD ALIGN="RIGHT">4</TD>
071 *     </TR>
072 *     <TR>
073 *       <TD ALIGN="LEFT">COMPARE_FALSE</TD>
074 *       <TD ALIGN="RIGHT">5</TD>
075 *     </TR>
076 *     <TR>
077 *       <TD ALIGN="LEFT">COMPARE_TRUE</TD>
078 *       <TD ALIGN="RIGHT">6</TD>
079 *     </TR>
080 *     <TR>
081 *       <TD ALIGN="LEFT">AUTH_METHOD_NOT_SUPPORTED</TD>
082 *       <TD ALIGN="RIGHT">7</TD>
083 *     </TR>
084 *     <TR>
085 *       <TD ALIGN="LEFT">STRONG_AUTH_REQUIRED</TD>
086 *       <TD ALIGN="RIGHT">8</TD>
087 *     </TR>
088 *     <TR>
089 *       <TD ALIGN="LEFT">REFERRAL</TD>
090 *       <TD ALIGN="RIGHT">10</TD>
091 *     </TR>
092 *     <TR>
093 *       <TD ALIGN="LEFT">ADMIN_LIMIT_EXCEEDED</TD>
094 *       <TD ALIGN="RIGHT">11</TD>
095 *     </TR>
096 *     <TR>
097 *       <TD ALIGN="LEFT">UNAVAILABLE_CRITICAL_EXTENSION</TD>
098 *       <TD ALIGN="RIGHT">12</TD>
099 *     </TR>
100 *     <TR>
101 *       <TD ALIGN="LEFT">CONFIDENTIALITY_REQUIRED</TD>
102 *       <TD ALIGN="RIGHT">13</TD>
103 *     </TR>
104 *     <TR>
105 *       <TD ALIGN="LEFT">SASL_BIND_IN_PROGRESS</TD>
106 *       <TD ALIGN="RIGHT">14</TD>
107 *     </TR>
108 *     <TR>
109 *       <TD ALIGN="LEFT">NO_SUCH_ATTRIBUTE</TD>
110 *       <TD ALIGN="RIGHT">16</TD>
111 *     </TR>
112 *     <TR>
113 *       <TD ALIGN="LEFT">UNDEFINED_ATTRIBUTE_TYPE</TD>
114 *       <TD ALIGN="RIGHT">17</TD>
115 *     </TR>
116 *     <TR>
117 *       <TD ALIGN="LEFT">INAPPROPRIATE_MATCHING</TD>
118 *       <TD ALIGN="RIGHT">18</TD>
119 *     </TR>
120 *     <TR>
121 *       <TD ALIGN="LEFT">CONSTRAINT_VIOLATION</TD>
122 *       <TD ALIGN="RIGHT">19</TD>
123 *     </TR>
124 *     <TR>
125 *       <TD ALIGN="LEFT">ATTRIBUTE_OR_VALUE_EXISTS</TD>
126 *       <TD ALIGN="RIGHT">20</TD>
127 *     </TR>
128 *     <TR>
129 *       <TD ALIGN="LEFT">INVALID_ATTRIBUTE_SYNTAX</TD>
130 *       <TD ALIGN="RIGHT">21</TD>
131 *     </TR>
132 *     <TR>
133 *       <TD ALIGN="LEFT">NO_SUCH_OBJECT</TD>
134 *       <TD ALIGN="RIGHT">32</TD>
135 *     </TR>
136 *     <TR>
137 *       <TD ALIGN="LEFT">ALIAS_PROBLEM</TD>
138 *       <TD ALIGN="RIGHT">33</TD>
139 *     </TR>
140 *     <TR>
141 *       <TD ALIGN="LEFT">INVALID_DN_SYNTAX</TD>
142 *       <TD ALIGN="RIGHT">34</TD>
143 *     </TR>
144 *     <TR>
145 *       <TD ALIGN="LEFT">ALIAS_DEREFERENCING_PROBLEM</TD>
146 *       <TD ALIGN="RIGHT">36</TD>
147 *     </TR>
148 *     <TR>
149 *       <TD ALIGN="LEFT">INAPPROPRIATE_AUTHENTICATION</TD>
150 *       <TD ALIGN="RIGHT">48</TD>
151 *     </TR>
152 *     <TR>
153 *       <TD ALIGN="LEFT">INVALID_CREDENTIALS</TD>
154 *       <TD ALIGN="RIGHT">49</TD>
155 *     </TR>
156 *     <TR>
157 *       <TD ALIGN="LEFT">INSUFFICIENT_ACCESS_RIGHTS</TD>
158 *       <TD ALIGN="RIGHT">50</TD>
159 *     </TR>
160 *     <TR>
161 *       <TD ALIGN="LEFT">BUSY</TD>
162 *       <TD ALIGN="RIGHT">51</TD>
163 *     </TR>
164 *     <TR>
165 *       <TD ALIGN="LEFT">UNAVAILABLE</TD>
166 *       <TD ALIGN="RIGHT">52</TD>
167 *     </TR>
168 *     <TR>
169 *       <TD ALIGN="LEFT">UNWILLING_TO_PERFORM</TD>
170 *       <TD ALIGN="RIGHT">53</TD>
171 *     </TR>
172 *     <TR>
173 *       <TD ALIGN="LEFT">LOOP_DETECT</TD>
174 *       <TD ALIGN="RIGHT">54</TD>
175 *     </TR>
176 *     <TR>
177 *       <TD ALIGN="LEFT">SORT_CONTROL_MISSING</TD>
178 *       <TD ALIGN="RIGHT">60</TD>
179 *     </TR>
180 *     <TR>
181 *       <TD ALIGN="LEFT">OFFSET_RANGE_ERROR</TD>
182 *       <TD ALIGN="RIGHT">61</TD>
183 *     </TR>
184 *     <TR>
185 *       <TD ALIGN="LEFT">NAMING_VIOLATION</TD>
186 *       <TD ALIGN="RIGHT">64</TD>
187 *     </TR>
188 *     <TR>
189 *       <TD ALIGN="LEFT">OBJECT_CLASS_VIOLATION</TD>
190 *       <TD ALIGN="RIGHT">65</TD>
191 *     </TR>
192 *     <TR>
193 *       <TD ALIGN="LEFT">NOT_ALLOWED_ON_NONLEAF</TD>
194 *       <TD ALIGN="RIGHT">66</TD>
195 *     </TR>
196 *     <TR>
197 *       <TD ALIGN="LEFT">NOT_ALLOWED_ON_NONLEAF</TD>
198 *       <TD ALIGN="RIGHT">66</TD>
199 *     </TR>
200 *     <TR>
201 *       <TD ALIGN="LEFT">NOT_ALLOWED_ON_RDN</TD>
202 *       <TD ALIGN="RIGHT">67</TD>
203 *     </TR>
204 *     <TR>
205 *       <TD ALIGN="LEFT">ENTRY_ALREADY_EXISTS</TD>
206 *       <TD ALIGN="RIGHT">68</TD>
207 *     </TR>
208 *     <TR>
209 *       <TD ALIGN="LEFT">OBJECT_CLASS_MODS_PROHIBITED</TD>
210 *       <TD ALIGN="RIGHT">69</TD>
211 *     </TR>
212 *     <TR>
213 *       <TD ALIGN="LEFT">AFFECTS_MULTIPLE_DSAS</TD>
214 *       <TD ALIGN="RIGHT">71</TD>
215 *     </TR>
216 *     <TR>
217 *       <TD ALIGN="LEFT">VIRTUAL_LIST_VIEW_ERROR</TD>
218 *       <TD ALIGN="RIGHT">76</TD>
219 *     </TR>
220 *     <TR>
221 *       <TD ALIGN="LEFT">OTHER</TD>
222 *       <TD ALIGN="RIGHT">80</TD>
223 *     </TR>
224 *     <TR>
225 *       <TD ALIGN="LEFT">SERVER_DOWN</TD>
226 *       <TD ALIGN="RIGHT">81</TD>
227 *     </TR>
228 *     <TR>
229 *       <TD ALIGN="LEFT">LOCAL_ERROR</TD>
230 *       <TD ALIGN="RIGHT">82</TD>
231 *     </TR>
232 *     <TR>
233 *       <TD ALIGN="LEFT">ENCODING_ERROR</TD>
234 *       <TD ALIGN="RIGHT">83</TD>
235 *     </TR>
236 *     <TR>
237 *       <TD ALIGN="LEFT">DECODING_ERROR</TD>
238 *       <TD ALIGN="RIGHT">84</TD>
239 *     </TR>
240 *     <TR>
241 *       <TD ALIGN="LEFT">TIMEOUT</TD>
242 *       <TD ALIGN="RIGHT">85</TD>
243 *     </TR>
244 *     <TR>
245 *       <TD ALIGN="LEFT">AUTH_UNKNOWN</TD>
246 *       <TD ALIGN="RIGHT">86</TD>
247 *     </TR>
248 *     <TR>
249 *       <TD ALIGN="LEFT">FILTER_ERROR</TD>
250 *       <TD ALIGN="RIGHT">87</TD>
251 *     </TR>
252 *     <TR>
253 *       <TD ALIGN="LEFT">USER_CANCELED</TD>
254 *       <TD ALIGN="RIGHT">88</TD>
255 *     </TR>
256 *     <TR>
257 *       <TD ALIGN="LEFT">PARAM_ERROR</TD>
258 *       <TD ALIGN="RIGHT">89</TD>
259 *     </TR>
260 *     <TR>
261 *       <TD ALIGN="LEFT">NO_MEMORY</TD>
262 *       <TD ALIGN="RIGHT">90</TD>
263 *     </TR>
264 *     <TR>
265 *       <TD ALIGN="LEFT">CONNECT_ERROR</TD>
266 *       <TD ALIGN="RIGHT">91</TD>
267 *     </TR>
268 *     <TR>
269 *       <TD ALIGN="LEFT">NOT_SUPPORTED</TD>
270 *       <TD ALIGN="RIGHT">92</TD>
271 *     </TR>
272 *     <TR>
273 *       <TD ALIGN="LEFT">CONTROL_NOT_FOUND</TD>
274 *       <TD ALIGN="RIGHT">93</TD>
275 *     </TR>
276 *     <TR>
277 *       <TD ALIGN="LEFT">NO_RESULTS_RETURNED</TD>
278 *       <TD ALIGN="RIGHT">94</TD>
279 *     </TR>
280 *     <TR>
281 *       <TD ALIGN="LEFT">MORE_RESULTS_TO_RETURN</TD>
282 *       <TD ALIGN="RIGHT">95</TD>
283 *     </TR>
284 *     <TR>
285 *       <TD ALIGN="LEFT">CLIENT_LOOP</TD>
286 *       <TD ALIGN="RIGHT">96</TD>
287 *     </TR>
288 *     <TR>
289 *       <TD ALIGN="LEFT">REFERRAL_LIMIT_EXCEEDED</TD>
290 *       <TD ALIGN="RIGHT">97</TD>
291 *     </TR>
292 *     <TR>
293 *       <TD ALIGN="LEFT">CANCELED</TD>
294 *       <TD ALIGN="RIGHT">118</TD>
295 *     </TR>
296 *     <TR>
297 *       <TD ALIGN="LEFT">NO_SUCH_OPERATION</TD>
298 *       <TD ALIGN="RIGHT">119</TD>
299 *     </TR>
300 *     <TR>
301 *       <TD ALIGN="LEFT">TOO_LATE</TD>
302 *       <TD ALIGN="RIGHT">120</TD>
303 *     </TR>
304 *     <TR>
305 *       <TD ALIGN="LEFT">CANNOT_CANCEL</TD>
306 *       <TD ALIGN="RIGHT">121</TD>
307 *     </TR>
308 *     <TR>
309 *       <TD ALIGN="LEFT">ASSERTION_FAILED</TD>
310 *       <TD ALIGN="RIGHT">122</TD>
311 *     </TR>
312 *     <TR>
313 *       <TD ALIGN="LEFT">AUTHORIZATION_DENIED</TD>
314 *       <TD ALIGN="RIGHT">123</TD>
315 *     </TR>
316 *     <TR>
317 *       <TD ALIGN="LEFT">E_SYNC_REFRESH_REQUIRED</TD>
318 *       <TD ALIGN="RIGHT">4096</TD>
319 *     </TR>
320 *     <TR>
321 *       <TD ALIGN="LEFT">NO_OPERATION</TD>
322 *       <TD ALIGN="RIGHT">16654</TD>
323 *     </TR>
324 *     <TR>
325 *       <TD ALIGN="LEFT">INTERACTIVE_TRANSACTION_ABORTED</TD>
326 *       <TD ALIGN="RIGHT">30221001</TD>
327 *     </TR>
328 *     <TR>
329 *       <TD ALIGN="LEFT">DATABASE_LOCK_CONFLICT</TD>
330 *       <TD ALIGN="RIGHT">30221002</TD>
331 *     </TR>
332 *     <TR>
333 *       <TD ALIGN="LEFT">MIRRORED_SUBTREE_DIGEST_MISMATCH</TD>
334 *       <TD ALIGN="RIGHT">30221003</TD>
335 *     </TR>
336 *     <TR>
337 *       <TD ALIGN="LEFT">TOKEN_DELIVERY_MECHANISM_UNAVAILABLE</TD>
338 *       <TD ALIGN="RIGHT">30221004</TD>
339 *     </TR>
340 *     <TR>
341 *       <TD ALIGN="LEFT">TOKEN_DELIVERY_ATTEMPT_FAILED</TD>
342 *       <TD ALIGN="RIGHT">30221005</TD>
343 *     </TR>
344 *     <TR>
345 *       <TD ALIGN="LEFT">TOKEN_DELIVERY_INVALID_RECIPIENT_ID</TD>
346 *       <TD ALIGN="RIGHT">30221006</TD>
347 *     </TR>
348 *     <TR>
349 *       <TD ALIGN="LEFT">TOKEN_DELIVERY_INVALID_ACCOUNT_STATE</TD>
350 *       <TD ALIGN="RIGHT">30221007</TD>
351 *     </TR>
352 *   </TABLE>
353 * </CENTER>
354 */
355@NotMutable()
356@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
357public final class ResultCode
358       implements Serializable
359{
360  /**
361   * The integer value (0) for the "SUCCESS" result code.
362   */
363  public static final int SUCCESS_INT_VALUE = 0;
364
365
366
367  /**
368   * The result code (0) that will be used to indicate a successful operation.
369   */
370  public static final ResultCode SUCCESS =
371       new ResultCode(INFO_RC_SUCCESS.get(), SUCCESS_INT_VALUE);
372
373
374
375  /**
376   * The integer value (1) for the "OPERATIONS_ERROR" result code.
377   */
378  public static final int OPERATIONS_ERROR_INT_VALUE = 1;
379
380
381
382  /**
383   * The result code (1) that will be used to indicate that an operation was
384   * requested out of sequence.
385   */
386  public static final ResultCode OPERATIONS_ERROR =
387       new ResultCode(INFO_RC_OPERATIONS_ERROR.get(),
388                      OPERATIONS_ERROR_INT_VALUE);
389
390
391
392  /**
393   * The integer value (2) for the "PROTOCOL_ERROR" result code.
394   */
395  public static final int PROTOCOL_ERROR_INT_VALUE = 2;
396
397
398
399  /**
400   * The result code (2) that will be used to indicate that the client sent a
401   * malformed request.
402   */
403  public static final ResultCode PROTOCOL_ERROR =
404       new ResultCode(INFO_RC_PROTOCOL_ERROR.get(), PROTOCOL_ERROR_INT_VALUE);
405
406
407
408  /**
409   * The integer value (3) for the "TIME_LIMIT_EXCEEDED" result code.
410   */
411  public static final int TIME_LIMIT_EXCEEDED_INT_VALUE = 3;
412
413
414
415  /**
416   * The result code (3) that will be used to indicate that the server was
417   * unable to complete processing on the request in the allotted time limit.
418   */
419  public static final ResultCode TIME_LIMIT_EXCEEDED =
420       new ResultCode(INFO_RC_TIME_LIMIT_EXCEEDED.get(),
421                      TIME_LIMIT_EXCEEDED_INT_VALUE);
422
423
424
425  /**
426   * The integer value (4) for the "SIZE_LIMIT_EXCEEDED" result code.
427   */
428  public static final int SIZE_LIMIT_EXCEEDED_INT_VALUE = 4;
429
430
431
432  /**
433   * The result code (4) that will be used to indicate that the server found
434   * more matching entries than the configured request size limit.
435   */
436  public static final ResultCode SIZE_LIMIT_EXCEEDED =
437       new ResultCode(INFO_RC_SIZE_LIMIT_EXCEEDED.get(),
438                      SIZE_LIMIT_EXCEEDED_INT_VALUE);
439
440
441
442  /**
443   * The integer value (5) for the "COMPARE_FALSE" result code.
444   */
445  public static final int COMPARE_FALSE_INT_VALUE = 5;
446
447
448
449  /**
450   * The result code (5) that will be used if a requested compare assertion does
451   * not match the target entry.
452   */
453  public static final ResultCode COMPARE_FALSE =
454       new ResultCode(INFO_RC_COMPARE_FALSE.get(), COMPARE_FALSE_INT_VALUE);
455
456
457
458  /**
459   * The integer value (6) for the "COMPARE_TRUE" result code.
460   */
461  public static final int COMPARE_TRUE_INT_VALUE = 6;
462
463
464
465  /**
466   * The result code (6) that will be used if a requested compare assertion
467   * matched the target entry.
468   */
469  public static final ResultCode COMPARE_TRUE =
470       new ResultCode(INFO_RC_COMPARE_TRUE.get(), COMPARE_TRUE_INT_VALUE);
471
472
473
474  /**
475   * The integer value (7) for the "AUTH_METHOD_NOT_SUPPORTED" result code.
476   */
477  public static final int AUTH_METHOD_NOT_SUPPORTED_INT_VALUE = 7;
478
479
480
481  /**
482   * The result code (7) that will be used if the client requested a form of
483   * authentication that is not supported by the server.
484   */
485  public static final ResultCode AUTH_METHOD_NOT_SUPPORTED =
486       new ResultCode(INFO_RC_AUTH_METHOD_NOT_SUPPORTED.get(),
487                      AUTH_METHOD_NOT_SUPPORTED_INT_VALUE);
488
489
490
491  /**
492   * The integer value (8) for the "STRONG_AUTH_REQUIRED" result code.
493   */
494  public static final int STRONG_AUTH_REQUIRED_INT_VALUE = 8;
495
496
497
498  /**
499   * The result code (8) that will be used if the client requested an operation
500   * that requires a strong authentication mechanism.
501   */
502  public static final ResultCode STRONG_AUTH_REQUIRED =
503       new ResultCode(INFO_RC_STRONG_AUTH_REQUIRED.get(),
504                      STRONG_AUTH_REQUIRED_INT_VALUE);
505
506
507
508  /**
509   * The integer value (10) for the "REFERRAL" result code.
510   */
511  public static final int REFERRAL_INT_VALUE = 10;
512
513
514
515  /**
516   * The result code (10) that will be used if the server sends a referral to
517   * the client to refer to data in another location.
518   */
519  public static final ResultCode REFERRAL =
520       new ResultCode(INFO_RC_REFERRAL.get(), REFERRAL_INT_VALUE);
521
522
523
524  /**
525   * The integer value (11) for the "ADMIN_LIMIT_EXCEEDED" result code.
526   */
527  public static final int ADMIN_LIMIT_EXCEEDED_INT_VALUE = 11;
528
529
530
531  /**
532   * The result code (11) that will be used if a server administrative limit has
533   * been exceeded.
534   */
535  public static final ResultCode ADMIN_LIMIT_EXCEEDED =
536       new ResultCode(INFO_RC_ADMIN_LIMIT_EXCEEDED.get(),
537                      ADMIN_LIMIT_EXCEEDED_INT_VALUE);
538
539
540
541  /**
542   * The integer value (12) for the "UNAVAILABLE_CRITICAL_EXTENSION" result
543   * code.
544   */
545  public static final int UNAVAILABLE_CRITICAL_EXTENSION_INT_VALUE = 12;
546
547
548
549  /**
550   * The result code (12) that will be used if the client requests a critical
551   * control that is not supported by the server.
552   */
553  public static final ResultCode UNAVAILABLE_CRITICAL_EXTENSION =
554       new ResultCode(INFO_RC_UNAVAILABLE_CRITICAL_EXTENSION.get(),
555                      UNAVAILABLE_CRITICAL_EXTENSION_INT_VALUE);
556
557
558
559  /**
560   * The integer value (13) for the "CONFIDENTIALITY_REQUIRED" result code.
561   */
562  public static final int CONFIDENTIALITY_REQUIRED_INT_VALUE = 13;
563
564
565
566  /**
567   * The result code (13) that will be used if the server requires a secure
568   * communication mechanism for the requested operation.
569   */
570  public static final ResultCode CONFIDENTIALITY_REQUIRED =
571       new ResultCode(INFO_RC_CONFIDENTIALITY_REQUIRED.get(),
572                      CONFIDENTIALITY_REQUIRED_INT_VALUE);
573
574
575
576  /**
577   * The integer value (14) for the "SASL_BIND_IN_PROGRESS" result code.
578   */
579  public static final int SASL_BIND_IN_PROGRESS_INT_VALUE = 14;
580
581
582
583  /**
584   * The result code (14) that will be returned from the server after SASL bind
585   * stages in which more processing is required.
586   */
587  public static final ResultCode SASL_BIND_IN_PROGRESS =
588       new ResultCode(INFO_RC_SASL_BIND_IN_PROGRESS.get(),
589                      SASL_BIND_IN_PROGRESS_INT_VALUE);
590
591
592
593  /**
594   * The integer value (16) for the "NO_SUCH_ATTRIBUTE" result code.
595   */
596  public static final int NO_SUCH_ATTRIBUTE_INT_VALUE = 16;
597
598
599
600  /**
601   * The result code (16) that will be used if the client referenced an
602   * attribute that does not exist in the target entry.
603   */
604  public static final ResultCode NO_SUCH_ATTRIBUTE =
605       new ResultCode(INFO_RC_NO_SUCH_ATTRIBUTE.get(),
606                      NO_SUCH_ATTRIBUTE_INT_VALUE);
607
608
609
610  /**
611   * The integer value (17) for the "UNDEFINED_ATTRIBUTE_TYPE" result code.
612   */
613  public static final int UNDEFINED_ATTRIBUTE_TYPE_INT_VALUE = 17;
614
615
616
617  /**
618   * The result code (17) that will be used if the client referenced an
619   * attribute that is not defined in the server schema.
620   */
621  public static final ResultCode UNDEFINED_ATTRIBUTE_TYPE =
622       new ResultCode(INFO_RC_UNDEFINED_ATTRIBUTE_TYPE.get(),
623                      UNDEFINED_ATTRIBUTE_TYPE_INT_VALUE);
624
625
626
627  /**
628   * The integer value (18) for the "INAPPROPRIATE_MATCHING" result code.
629   */
630  public static final int INAPPROPRIATE_MATCHING_INT_VALUE = 18;
631
632
633
634  /**
635   * The result code (18) that will be used if the client attempted to use an
636   * attribute in a search filter in a manner not supported by the matching
637   * rules associated with that attribute.
638   */
639  public static final ResultCode INAPPROPRIATE_MATCHING =
640       new ResultCode(INFO_RC_INAPPROPRIATE_MATCHING.get(),
641                      INAPPROPRIATE_MATCHING_INT_VALUE);
642
643
644
645  /**
646   * The integer value (19) for the "CONSTRAINT_VIOLATION" result code.
647   */
648  public static final int CONSTRAINT_VIOLATION_INT_VALUE = 19;
649
650
651
652  /**
653   * The result code (19) that will be used if the requested operation would
654   * violate some constraint defined in the server.
655   */
656  public static final ResultCode CONSTRAINT_VIOLATION =
657       new ResultCode(INFO_RC_CONSTRAINT_VIOLATION.get(),
658                      CONSTRAINT_VIOLATION_INT_VALUE);
659
660
661
662  /**
663   * The integer value (20) for the "ATTRIBUTE_OR_VALUE_EXISTS" result code.
664   */
665  public static final int ATTRIBUTE_OR_VALUE_EXISTS_INT_VALUE = 20;
666
667
668
669  /**
670   * The result code (20) that will be used if the client attempts to modify an
671   * entry in a way that would create a duplicate value, or create multiple
672   * values for a single-valued attribute.
673   */
674  public static final ResultCode ATTRIBUTE_OR_VALUE_EXISTS =
675       new ResultCode(INFO_RC_ATTRIBUTE_OR_VALUE_EXISTS.get(),
676                      ATTRIBUTE_OR_VALUE_EXISTS_INT_VALUE);
677
678
679
680  /**
681   * The integer value (21) for the "INVALID_ATTRIBUTE_SYNTAX" result code.
682   */
683  public static final int INVALID_ATTRIBUTE_SYNTAX_INT_VALUE = 21;
684
685
686
687  /**
688   * The result code (21) that will be used if the client attempts to perform an
689   * operation that would create an attribute value that violates the syntax
690   * for that attribute.
691   */
692  public static final ResultCode INVALID_ATTRIBUTE_SYNTAX =
693       new ResultCode(INFO_RC_INVALID_ATTRIBUTE_SYNTAX.get(),
694                      INVALID_ATTRIBUTE_SYNTAX_INT_VALUE);
695
696
697
698  /**
699   * The integer value (32) for the "NO_SUCH_OBJECT" result code.
700   */
701  public static final int NO_SUCH_OBJECT_INT_VALUE = 32;
702
703
704
705  /**
706   * The result code (32) that will be used if the client targeted an entry that
707   * does not exist.
708   */
709  public static final ResultCode NO_SUCH_OBJECT =
710       new ResultCode(INFO_RC_NO_SUCH_OBJECT.get(), NO_SUCH_OBJECT_INT_VALUE);
711
712
713
714  /**
715   * The integer value (33) for the "ALIAS_PROBLEM" result code.
716   */
717  public static final int ALIAS_PROBLEM_INT_VALUE = 33;
718
719
720
721  /**
722   * The result code (33) that will be used if the client targeted an entry that
723   * as an alias.
724   */
725  public static final ResultCode ALIAS_PROBLEM =
726       new ResultCode(INFO_RC_ALIAS_PROBLEM.get(), ALIAS_PROBLEM_INT_VALUE);
727
728
729
730  /**
731   * The integer value (34) for the "INVALID_DN_SYNTAX" result code.
732   */
733  public static final int INVALID_DN_SYNTAX_INT_VALUE = 34;
734
735
736
737  /**
738   * The result code (34) that will be used if the client provided an invalid
739   * DN.
740   */
741  public static final ResultCode INVALID_DN_SYNTAX =
742       new ResultCode(INFO_RC_INVALID_DN_SYNTAX.get(),
743                      INVALID_DN_SYNTAX_INT_VALUE);
744
745
746
747  /**
748   * The integer value (36) for the "ALIAS_DEREFERENCING_PROBLEM" result code.
749   */
750  public static final int ALIAS_DEREFERENCING_PROBLEM_INT_VALUE = 36;
751
752
753
754  /**
755   * The result code (36) that will be used if a problem is encountered while
756   * the server is attempting to dereference an alias.
757   */
758  public static final ResultCode ALIAS_DEREFERENCING_PROBLEM =
759       new ResultCode(INFO_RC_ALIAS_DEREFERENCING_PROBLEM.get(),
760                      ALIAS_DEREFERENCING_PROBLEM_INT_VALUE);
761
762
763
764  /**
765   * The integer value (48) for the "INAPPROPRIATE_AUTHENTICATION" result code.
766   */
767  public static final int INAPPROPRIATE_AUTHENTICATION_INT_VALUE = 48;
768
769
770
771  /**
772   * The result code (48) that will be used if the client attempts to perform a
773   * type of authentication that is not supported for the target user.
774   */
775  public static final ResultCode INAPPROPRIATE_AUTHENTICATION =
776       new ResultCode(INFO_RC_INAPPROPRIATE_AUTHENTICATION.get(),
777                      INAPPROPRIATE_AUTHENTICATION_INT_VALUE);
778
779
780
781  /**
782   * The integer value (49) for the "INVALID_CREDENTIALS" result code.
783   */
784  public static final int INVALID_CREDENTIALS_INT_VALUE = 49;
785
786
787
788  /**
789   * The result code (49) that will be used if the client provided invalid
790   * credentials while trying to authenticate.
791   */
792  public static final ResultCode INVALID_CREDENTIALS =
793       new ResultCode(INFO_RC_INVALID_CREDENTIALS.get(),
794                      INVALID_CREDENTIALS_INT_VALUE);
795
796
797
798  /**
799   * The integer value (50) for the "INSUFFICIENT_ACCESS_RIGHTS" result code.
800   */
801  public static final int INSUFFICIENT_ACCESS_RIGHTS_INT_VALUE = 50;
802
803
804
805  /**
806   * The result code (50) that will be used if the client does not have
807   * permission to perform the requested operation.
808   */
809  public static final ResultCode INSUFFICIENT_ACCESS_RIGHTS =
810       new ResultCode(INFO_RC_INSUFFICIENT_ACCESS_RIGHTS.get(),
811                      INSUFFICIENT_ACCESS_RIGHTS_INT_VALUE);
812
813
814
815  /**
816   * The integer value (51) for the "BUSY" result code.
817   */
818  public static final int BUSY_INT_VALUE = 51;
819
820
821
822  /**
823   * The result code (51) that will be used if the server is too busy to process
824   * the requested operation.
825   */
826  public static final ResultCode BUSY = new ResultCode(INFO_RC_BUSY.get(),
827                                                       BUSY_INT_VALUE);
828
829
830
831  /**
832   * The integer value (52) for the "UNAVAILABLE" result code.
833   */
834  public static final int UNAVAILABLE_INT_VALUE = 52;
835
836
837
838  /**
839   * The result code (52) that will be used if the server is unavailable.
840   */
841  public static final ResultCode UNAVAILABLE =
842       new ResultCode(INFO_RC_UNAVAILABLE.get(), UNAVAILABLE_INT_VALUE);
843
844
845
846  /**
847   * The integer value (53) for the "UNWILLING_TO_PERFORM" result code.
848   */
849  public static final int UNWILLING_TO_PERFORM_INT_VALUE = 53;
850
851
852
853  /**
854   * The result code (53) that will be used if the server is not willing to
855   * perform the requested operation.
856   */
857  public static final ResultCode UNWILLING_TO_PERFORM =
858       new ResultCode(INFO_RC_UNWILLING_TO_PERFORM.get(),
859                      UNWILLING_TO_PERFORM_INT_VALUE);
860
861
862
863  /**
864   * The integer value (54) for the "LOOP_DETECT" result code.
865   */
866  public static final int LOOP_DETECT_INT_VALUE = 54;
867
868
869
870  /**
871   * The result code (54) that will be used if the server detects a chaining or
872   * alias loop.
873   */
874  public static final ResultCode LOOP_DETECT =
875       new ResultCode(INFO_RC_LOOP_DETECT.get(), LOOP_DETECT_INT_VALUE);
876
877
878
879  /**
880   * The integer value (60) for the "SORT_CONTROL_MISSING" result code.
881   */
882  public static final int SORT_CONTROL_MISSING_INT_VALUE = 60;
883
884
885
886  /**
887   * The result code (60) that will be used if the client sends a virtual list
888   * view control without a server-side sort control.
889   */
890  public static final ResultCode SORT_CONTROL_MISSING =
891       new ResultCode(INFO_RC_SORT_CONTROL_MISSING.get(),
892                      SORT_CONTROL_MISSING_INT_VALUE);
893
894
895
896  /**
897   * The integer value (61) for the "OFFSET_RANGE_ERROR" result code.
898   */
899  public static final int OFFSET_RANGE_ERROR_INT_VALUE = 61;
900
901
902
903  /**
904   * The result code (61) that will be used if the client provides a virtual
905   * list view control with a target offset that is out of range for the
906   * available data set.
907   */
908  public static final ResultCode OFFSET_RANGE_ERROR =
909       new ResultCode(INFO_RC_OFFSET_RANGE_ERROR.get(),
910                      OFFSET_RANGE_ERROR_INT_VALUE);
911
912
913
914  /**
915   * The integer value (64) for the "NAMING_VIOLATION" result code.
916   */
917  public static final int NAMING_VIOLATION_INT_VALUE = 64;
918
919
920
921  /**
922   * The result code (64) that will be used if the client request violates a
923   * naming constraint (e.g., a name form or DIT structure rule) defined in the
924   * server.
925   */
926  public static final ResultCode NAMING_VIOLATION =
927       new ResultCode(INFO_RC_NAMING_VIOLATION.get(),
928                      NAMING_VIOLATION_INT_VALUE);
929
930
931
932  /**
933   * The integer value (65) for the "OBJECT_CLASS_VIOLATION" result code.
934   */
935  public static final int OBJECT_CLASS_VIOLATION_INT_VALUE = 65;
936
937
938
939  /**
940   * The result code (65) that will be used if the client request violates an
941   * object class constraint (e.g., an undefined object class, a
942   * disallowed attribute, or a missing required attribute) defined in the
943   * server.
944   */
945  public static final ResultCode OBJECT_CLASS_VIOLATION =
946       new ResultCode(INFO_RC_OBJECT_CLASS_VIOLATION.get(),
947                      OBJECT_CLASS_VIOLATION_INT_VALUE);
948
949
950
951  /**
952   * The integer value (66) for the "NOT_ALLOWED_ON_NONLEAF" result code.
953   */
954  public static final int NOT_ALLOWED_ON_NONLEAF_INT_VALUE = 66;
955
956
957
958  /**
959   * The result code (66) that will be used if the requested operation is not
960   * allowed to be performed on non-leaf entries.
961   */
962  public static final ResultCode NOT_ALLOWED_ON_NONLEAF =
963       new ResultCode(INFO_RC_NOT_ALLOWED_ON_NONLEAF.get(),
964                      NOT_ALLOWED_ON_NONLEAF_INT_VALUE);
965
966
967
968  /**
969   * The integer value (67) for the "NOT_ALLOWED_ON_RDN" result code.
970   */
971  public static final int NOT_ALLOWED_ON_RDN_INT_VALUE = 67;
972
973
974
975  /**
976   * The result code (67) that will be used if the requested operation would
977   * alter the RDN of the entry but the operation was not a modify DN request.
978   */
979  public static final ResultCode NOT_ALLOWED_ON_RDN =
980       new ResultCode(INFO_RC_NOT_ALLOWED_ON_RDN.get(),
981                      NOT_ALLOWED_ON_RDN_INT_VALUE);
982
983
984
985  /**
986   * The integer value (68) for the "ENTRY_ALREADY_EXISTS" result code.
987   */
988  public static final int ENTRY_ALREADY_EXISTS_INT_VALUE = 68;
989
990
991
992  /**
993   * The result code (68) that will be used if the requested operation would
994   * create a conflict with an entry that already exists in the server.
995   */
996  public static final ResultCode ENTRY_ALREADY_EXISTS =
997       new ResultCode(INFO_RC_ENTRY_ALREADY_EXISTS.get(),
998                      ENTRY_ALREADY_EXISTS_INT_VALUE);
999
1000
1001
1002  /**
1003   * The integer value (69) for the "OBJECT_CLASS_MODS_PROHIBITED" result code.
1004   */
1005  public static final int OBJECT_CLASS_MODS_PROHIBITED_INT_VALUE = 69;
1006
1007
1008
1009  /**
1010   * The result code (69) that will be used if the requested operation would
1011   * alter the set of object classes defined in the entry in a disallowed
1012   * manner.
1013   */
1014  public static final ResultCode OBJECT_CLASS_MODS_PROHIBITED =
1015       new ResultCode(INFO_RC_OBJECT_CLASS_MODS_PROHIBITED.get(),
1016                      OBJECT_CLASS_MODS_PROHIBITED_INT_VALUE);
1017
1018
1019
1020  /**
1021   * The integer value (71) for the "AFFECTS_MULTIPLE_DSAS" result code.
1022   */
1023  public static final int AFFECTS_MULTIPLE_DSAS_INT_VALUE = 71;
1024
1025
1026
1027  /**
1028   * The result code (71) that will be used if the requested operation would
1029   * impact entries in multiple data sources.
1030   */
1031  public static final ResultCode AFFECTS_MULTIPLE_DSAS =
1032       new ResultCode(INFO_RC_AFFECTS_MULTIPLE_DSAS.get(),
1033                      AFFECTS_MULTIPLE_DSAS_INT_VALUE);
1034
1035
1036
1037  /**
1038   * The integer value (76) for the "VIRTUAL_LIST_VIEW_ERROR" result code.
1039   */
1040  public static final int VIRTUAL_LIST_VIEW_ERROR_INT_VALUE = 76;
1041
1042
1043
1044  /**
1045   * The result code (76) that will be used if an error occurred while
1046   * performing processing associated with the virtual list view control.
1047   */
1048  public static final ResultCode VIRTUAL_LIST_VIEW_ERROR =
1049       new ResultCode(INFO_RC_VIRTUAL_LIST_VIEW_ERROR.get(),
1050                      VIRTUAL_LIST_VIEW_ERROR_INT_VALUE);
1051
1052
1053
1054  /**
1055   * The integer value (80) for the "OTHER" result code.
1056   */
1057  public static final int OTHER_INT_VALUE = 80;
1058
1059
1060
1061  /**
1062   * The result code (80) that will be used if none of the other result codes
1063   * are appropriate.
1064   */
1065  public static final ResultCode OTHER =
1066       new ResultCode(INFO_RC_OTHER.get(), OTHER_INT_VALUE);
1067
1068
1069
1070  /**
1071   * The integer value (81) for the "SERVER_DOWN" result code.
1072   */
1073  public static final int SERVER_DOWN_INT_VALUE = 81;
1074
1075
1076
1077  /**
1078   * The client-side result code (81) that will be used if an established
1079   * connection to the server is lost.
1080   */
1081  public static final ResultCode SERVER_DOWN =
1082       new ResultCode(INFO_RC_SERVER_DOWN.get(), SERVER_DOWN_INT_VALUE);
1083
1084
1085
1086  /**
1087   * The integer value (82) for the "LOCAL_ERROR" result code.
1088   */
1089  public static final int LOCAL_ERROR_INT_VALUE = 82;
1090
1091
1092
1093  /**
1094   * The client-side result code (82) that will be used if a generic client-side
1095   * error occurs during processing.
1096   */
1097  public static final ResultCode LOCAL_ERROR =
1098       new ResultCode(INFO_RC_LOCAL_ERROR.get(), LOCAL_ERROR_INT_VALUE);
1099
1100
1101
1102  /**
1103   * The integer value (83) for the "ENCODING_ERROR" result code.
1104   */
1105  public static final int ENCODING_ERROR_INT_VALUE = 83;
1106
1107
1108
1109  /**
1110   * The client-side result code (83) that will be used if an error occurs while
1111   * encoding a request.
1112   */
1113  public static final ResultCode ENCODING_ERROR =
1114       new ResultCode(INFO_RC_ENCODING_ERROR.get(), ENCODING_ERROR_INT_VALUE);
1115
1116
1117
1118  /**
1119   * The integer value (84) for the "DECODING_ERROR" result code.
1120   */
1121  public static final int DECODING_ERROR_INT_VALUE = 84;
1122
1123
1124
1125  /**
1126   * The client-side result code (84) that will be used if an error occurs while
1127   * decoding a response.
1128   */
1129  public static final ResultCode DECODING_ERROR =
1130       new ResultCode(INFO_RC_DECODING_ERROR.get(), DECODING_ERROR_INT_VALUE);
1131
1132
1133
1134  /**
1135   * The integer value (85) for the "TIMEOUT" result code.
1136   */
1137  public static final int TIMEOUT_INT_VALUE = 85;
1138
1139
1140
1141  /**
1142   * The client-side result code (85) that will be used if a client timeout
1143   * occurs while waiting for a response from the server.
1144   */
1145  public static final ResultCode TIMEOUT =
1146       new ResultCode(INFO_RC_TIMEOUT.get(), TIMEOUT_INT_VALUE);
1147
1148
1149
1150  /**
1151   * The integer value (86) for the "AUTH_UNKNOWN" result code.
1152   */
1153  public static final int AUTH_UNKNOWN_INT_VALUE = 86;
1154
1155
1156
1157  /**
1158   * The client-side result code (86) that will be used if the client attempts
1159   * to use an unknown authentication type.
1160   */
1161  public static final ResultCode AUTH_UNKNOWN =
1162       new ResultCode(INFO_RC_AUTH_UNKNOWN.get(), AUTH_UNKNOWN_INT_VALUE);
1163
1164
1165
1166  /**
1167   * The integer value (87) for the "FILTER_ERROR" result code.
1168   */
1169  public static final int FILTER_ERROR_INT_VALUE = 87;
1170
1171
1172
1173  /**
1174   * The client-side result code (87) that will be used if an error occurs while
1175   * attempting to encode a search filter.
1176   */
1177  public static final ResultCode FILTER_ERROR =
1178       new ResultCode(INFO_RC_FILTER_ERROR.get(), FILTER_ERROR_INT_VALUE);
1179
1180
1181
1182  /**
1183   * The integer value (88) for the "USER_CANCELED" result code.
1184   */
1185  public static final int USER_CANCELED_INT_VALUE = 88;
1186
1187
1188
1189  /**
1190   * The client-side result code (88) that will be used if the end user canceled
1191   * the operation in progress.
1192   */
1193  public static final ResultCode USER_CANCELED =
1194       new ResultCode(INFO_RC_USER_CANCELED.get(), USER_CANCELED_INT_VALUE);
1195
1196
1197
1198  /**
1199   * The integer value (89) for the "PARAM_ERROR" result code.
1200   */
1201  public static final int PARAM_ERROR_INT_VALUE = 89;
1202
1203
1204
1205  /**
1206   * The client-side result code (89) that will be used if there is a problem
1207   * with the parameters provided for a request.
1208   */
1209  public static final ResultCode PARAM_ERROR =
1210       new ResultCode(INFO_RC_PARAM_ERROR.get(), PARAM_ERROR_INT_VALUE);
1211
1212
1213
1214  /**
1215   * The integer value (90) for the "NO_MEMORY" result code.
1216   */
1217  public static final int NO_MEMORY_INT_VALUE = 90;
1218
1219
1220
1221  /**
1222   * The client-side result code (90) that will be used if the client does not
1223   * have sufficient memory to perform the requested operation.
1224   */
1225  public static final ResultCode NO_MEMORY =
1226       new ResultCode(INFO_RC_NO_MEMORY.get(), NO_MEMORY_INT_VALUE);
1227
1228
1229
1230  /**
1231   * The integer value (91) for the "CONNECT_ERROR" result code.
1232   */
1233  public static final int CONNECT_ERROR_INT_VALUE = 91;
1234
1235
1236
1237  /**
1238   * The client-side result code (91) that will be used if an error occurs while
1239   * attempting to connect to a target server.
1240   */
1241  public static final ResultCode CONNECT_ERROR =
1242       new ResultCode(INFO_RC_CONNECT_ERROR.get(), CONNECT_ERROR_INT_VALUE);
1243
1244
1245
1246  /**
1247   * The integer value (92) for the "NOT_SUPPORTED" result code.
1248   */
1249  public static final int NOT_SUPPORTED_INT_VALUE = 92;
1250
1251
1252
1253  /**
1254   * The client-side result code (92) that will be used if the requested
1255   * operation is not supported.
1256   */
1257  public static final ResultCode NOT_SUPPORTED =
1258       new ResultCode(INFO_RC_NOT_SUPPORTED.get(), NOT_SUPPORTED_INT_VALUE);
1259
1260
1261
1262  /**
1263   * The integer value (93) for the "CONTROL_NOT_FOUND" result code.
1264   */
1265  public static final int CONTROL_NOT_FOUND_INT_VALUE = 93;
1266
1267
1268
1269  /**
1270   * The client-side result code (93) that will be used if the response from the
1271   * server did not include an expected control.
1272   */
1273  public static final ResultCode CONTROL_NOT_FOUND =
1274       new ResultCode(INFO_RC_CONTROL_NOT_FOUND.get(),
1275                      CONTROL_NOT_FOUND_INT_VALUE);
1276
1277
1278
1279  /**
1280   * The integer value (94) for the "NO_RESULTS_RETURNED" result code.
1281   */
1282  public static final int NO_RESULTS_RETURNED_INT_VALUE = 94;
1283
1284
1285
1286  /**
1287   * The client-side result code (94) that will be used if the server did not
1288   * send any results.
1289   */
1290  public static final ResultCode NO_RESULTS_RETURNED =
1291       new ResultCode(INFO_RC_NO_RESULTS_RETURNED.get(),
1292                      NO_RESULTS_RETURNED_INT_VALUE);
1293
1294
1295
1296  /**
1297   * The integer value (95) for the "MORE_RESULTS_TO_RETURN" result code.
1298   */
1299  public static final int MORE_RESULTS_TO_RETURN_INT_VALUE = 95;
1300
1301
1302
1303  /**
1304   * The client-side result code (95) that will be used if there are still more
1305   * results to return.
1306   */
1307  public static final ResultCode MORE_RESULTS_TO_RETURN =
1308       new ResultCode(INFO_RC_MORE_RESULTS_TO_RETURN.get(),
1309                      MORE_RESULTS_TO_RETURN_INT_VALUE);
1310
1311
1312
1313  /**
1314   * The integer value (96) for the "CLIENT_LOOP" result code.
1315   */
1316  public static final int CLIENT_LOOP_INT_VALUE = 96;
1317
1318
1319
1320  /**
1321   * The client-side result code (96) that will be used if the client detects a
1322   * loop while attempting to follow referrals.
1323   */
1324  public static final ResultCode CLIENT_LOOP =
1325       new ResultCode(INFO_RC_CLIENT_LOOP.get(), CLIENT_LOOP_INT_VALUE);
1326
1327
1328
1329  /**
1330   * The integer value (97) for the "REFERRAL_LIMIT_EXCEEDED" result code.
1331   */
1332  public static final int REFERRAL_LIMIT_EXCEEDED_INT_VALUE = 97;
1333
1334
1335
1336  /**
1337   * The client-side result code (97) that will be used if the client
1338   * encountered too many referrals in the course of processing an operation.
1339   */
1340  public static final ResultCode REFERRAL_LIMIT_EXCEEDED =
1341       new ResultCode(INFO_RC_REFERRAL_LIMIT_EXCEEDED.get(),
1342                      REFERRAL_LIMIT_EXCEEDED_INT_VALUE);
1343
1344
1345
1346  /**
1347   * The integer value (118) for the "CANCELED" result code.
1348   */
1349  public static final int CANCELED_INT_VALUE = 118;
1350
1351
1352
1353  /**
1354   * The result code (118) that will be used if the operation was canceled.
1355   */
1356  public static final ResultCode CANCELED =
1357       new ResultCode(INFO_RC_CANCELED.get(), CANCELED_INT_VALUE);
1358
1359
1360
1361  /**
1362   * The integer value (119) for the "NO_SUCH_OPERATION" result code.
1363   */
1364  public static final int NO_SUCH_OPERATION_INT_VALUE = 119;
1365
1366
1367
1368  /**
1369   * The result code (119) that will be used if the client attempts to cancel an
1370   * operation that the client doesn't exist in the server.
1371   */
1372  public static final ResultCode NO_SUCH_OPERATION =
1373       new ResultCode(INFO_RC_NO_SUCH_OPERATION.get(),
1374                      NO_SUCH_OPERATION_INT_VALUE);
1375
1376
1377
1378  /**
1379   * The integer value (120) for the "TOO_LATE" result code.
1380   */
1381  public static final int TOO_LATE_INT_VALUE = 120;
1382
1383
1384
1385  /**
1386   * The result code (120) that will be used if the client attempts to cancel an
1387   * operation too late in the processing for that operation.
1388   */
1389  public static final ResultCode TOO_LATE =
1390       new ResultCode(INFO_RC_TOO_LATE.get(), TOO_LATE_INT_VALUE);
1391
1392
1393
1394  /**
1395   * The integer value (121) for the "CANNOT_CANCEL" result code.
1396   */
1397  public static final int CANNOT_CANCEL_INT_VALUE = 121;
1398
1399
1400
1401  /**
1402   * The result code (121) that will be used if the client attempts to cancel an
1403   * operation that cannot be canceled.
1404   */
1405  public static final ResultCode CANNOT_CANCEL =
1406       new ResultCode(INFO_RC_CANNOT_CANCEL.get(), CANNOT_CANCEL_INT_VALUE);
1407
1408
1409
1410  /**
1411   * The integer value (122) for the "ASSERTION_FAILED" result code.
1412   */
1413  public static final int ASSERTION_FAILED_INT_VALUE = 122;
1414
1415
1416
1417  /**
1418   * The result code (122) that will be used if the requested operation included
1419   * the LDAP assertion control but the assertion did not match the target
1420   * entry.
1421   */
1422  public static final ResultCode ASSERTION_FAILED =
1423       new ResultCode(INFO_RC_ASSERTION_FAILED.get(),
1424                      ASSERTION_FAILED_INT_VALUE);
1425
1426
1427
1428  /**
1429   * The integer value (123) for the "AUTHORIZATION_DENIED" result code.
1430   */
1431  public static final int AUTHORIZATION_DENIED_INT_VALUE = 123;
1432
1433
1434
1435  /**
1436   * The result code (123) that will be used if the client is denied the ability
1437   * to use the proxied authorization control.
1438   */
1439  public static final ResultCode AUTHORIZATION_DENIED =
1440       new ResultCode(INFO_RC_AUTHORIZATION_DENIED.get(),
1441                      AUTHORIZATION_DENIED_INT_VALUE);
1442
1443
1444
1445  /**
1446   * The integer value (4096) for the "E_SYNC_REFRESH_REQUIRED" result code.
1447   */
1448  public static final int E_SYNC_REFRESH_REQUIRED_INT_VALUE = 4096;
1449
1450
1451
1452  /**
1453   * The result code (4096) that will be used if a client using the content
1454   * synchronization request control requests an incremental update but the
1455   * server is unable to honor that request and requires the client to request
1456   * an initial content.
1457   */
1458  public static final ResultCode E_SYNC_REFRESH_REQUIRED =
1459       new ResultCode(INFO_RC_E_SYNC_REFRESH_REQUIRED.get(),
1460                      E_SYNC_REFRESH_REQUIRED_INT_VALUE);
1461
1462
1463
1464  /**
1465   * The integer value (16654) for the "NO_OPERATION" result code.
1466   */
1467  public static final int NO_OPERATION_INT_VALUE = 16654;
1468
1469
1470
1471  /**
1472   * The result code (16654) for operations that completed successfully but no
1473   * changes were made to the server because the LDAP no-op control was included
1474   * in the request.
1475   */
1476  public static final ResultCode NO_OPERATION =
1477       new ResultCode(INFO_RC_NO_OPERATION.get(), NO_OPERATION_INT_VALUE);
1478
1479
1480
1481  /**
1482   * The integer value (30221001) for the "INTERACTIVE_TRANSACTION_ABORTED"
1483   * result code.
1484   */
1485  public static final int INTERACTIVE_TRANSACTION_ABORTED_INT_VALUE = 30221001;
1486
1487
1488
1489  /**
1490   * The result code (30221001) for use if an interactive transaction has been
1491   * aborted, either due to an explicit request from a client or by the server
1492   * without a client request.
1493   */
1494  public static final ResultCode INTERACTIVE_TRANSACTION_ABORTED =
1495       new ResultCode(INFO_RC_INTERACTIVE_TRANSACTION_ABORTED.get(),
1496                      INTERACTIVE_TRANSACTION_ABORTED_INT_VALUE);
1497
1498
1499
1500  /**
1501   * The integer value (30221002) for the "DATABASE_LOCK_CONFLICT" result code.
1502   */
1503  public static final int DATABASE_LOCK_CONFLICT_INT_VALUE = 30221002;
1504
1505
1506
1507  /**
1508   * The result code (30221002) for use if an operation fails because of a
1509   * database lock conflict (e.g., a deadlock or lock timeout).
1510   */
1511  public static final ResultCode DATABASE_LOCK_CONFLICT =
1512       new ResultCode(INFO_RC_DATABASE_LOCK_CONFLICT.get(),
1513                      DATABASE_LOCK_CONFLICT_INT_VALUE);
1514
1515
1516
1517  /**
1518   * The integer value (30221003) for the "MIRRORED_SUBTREE_DIGEST_MISMATCH"
1519   * result code.
1520   */
1521  public static final int MIRRORED_SUBTREE_DIGEST_MISMATCH_INT_VALUE = 30221003;
1522
1523
1524
1525  /**
1526   * The result code (30221003) that should be used by a node in a topology of
1527   * servers to indicate that its subtree digest does not match that of its
1528   * master's.
1529   */
1530  public static final ResultCode MIRRORED_SUBTREE_DIGEST_MISMATCH =
1531      new ResultCode(INFO_RC_MIRRORED_SUBTREE_DIGEST_MISMATCH.get(),
1532          MIRRORED_SUBTREE_DIGEST_MISMATCH_INT_VALUE);
1533
1534
1535
1536  /**
1537   * The integer value (30221004) for the "TOKEN_DELIVERY_MECHANISM_UNAVAILABLE"
1538   * result code.
1539   */
1540  public static final int TOKEN_DELIVERY_MECHANISM_UNAVAILABLE_INT_VALUE =
1541       30221004;
1542
1543
1544
1545  /**
1546   * The result code (30221004) that should be used to indicate that the server
1547   * could not deliver a one-time password, password reset token, or single-use
1548   * token because none of the attempted delivery mechanisms were supported for
1549   * the target user.
1550   */
1551  public static final ResultCode TOKEN_DELIVERY_MECHANISM_UNAVAILABLE =
1552      new ResultCode(INFO_RC_TOKEN_DELIVERY_MECHANISM_UNAVAILABLE.get(),
1553          TOKEN_DELIVERY_MECHANISM_UNAVAILABLE_INT_VALUE);
1554
1555
1556
1557  /**
1558   * The integer value (30221005) for the "TOKEN_DELIVERY_ATTEMPT_FAILED"
1559   * result code.
1560   */
1561  public static final int TOKEN_DELIVERY_ATTEMPT_FAILED_INT_VALUE = 30221005;
1562
1563
1564
1565  /**
1566   * The result code (30221005) that should be used to indicate that the server
1567   * could not deliver a one-time password, password reset token, or single-use
1568   * token because a failure was encountered while attempting to deliver the
1569   * token through all of the supported mechanisms.
1570   */
1571  public static final ResultCode TOKEN_DELIVERY_ATTEMPT_FAILED =
1572      new ResultCode(INFO_RC_TOKEN_DELIVERY_ATTEMPT_FAILED.get(),
1573          TOKEN_DELIVERY_ATTEMPT_FAILED_INT_VALUE);
1574
1575
1576
1577  /**
1578   * The integer value (30221006) for the "TOKEN_DELIVERY_INVALID_RECIPIENT_ID"
1579   * result code.
1580   */
1581  public static final int TOKEN_DELIVERY_INVALID_RECIPIENT_ID_INT_VALUE =
1582       30221006;
1583
1584
1585
1586  /**
1587   * The result code (30221006) that should be used to indicate that the server
1588   * could not deliver a one-time password, password reset token, or single-use
1589   * token because the client specified a recipient ID that was not appropriate
1590   * for the target user.
1591   */
1592  public static final ResultCode TOKEN_DELIVERY_INVALID_RECIPIENT_ID =
1593      new ResultCode(INFO_RC_TOKEN_DELIVERY_INVALID_RECIPIENT_ID.get(),
1594          TOKEN_DELIVERY_INVALID_RECIPIENT_ID_INT_VALUE);
1595
1596
1597
1598  /**
1599   * The integer value (30221007) for the "TOKEN_DELIVERY_INVALID_ACCOUNT_STATE"
1600   * result code.
1601   */
1602  public static final int TOKEN_DELIVERY_INVALID_ACCOUNT_STATE_INT_VALUE =
1603       30221007;
1604
1605
1606
1607  /**
1608   * The result code (30221007) that should be used to indicate that the server
1609   * could not deliver a one-time password, password reset token, or single-use
1610   * token because the target user account was in an invalid state for receiving
1611   * such tokens (e.g., the account is disabled or locked, the password is
1612   * expired, etc.).
1613   */
1614  public static final ResultCode TOKEN_DELIVERY_INVALID_ACCOUNT_STATE =
1615      new ResultCode(INFO_RC_TOKEN_DELIVERY_INVALID_ACCOUNT_STATE.get(),
1616          TOKEN_DELIVERY_INVALID_ACCOUNT_STATE_INT_VALUE);
1617
1618
1619
1620  /**
1621   * The set of result code objects created with undefined int result code
1622   * values.
1623   */
1624  private static final ConcurrentHashMap<Integer,ResultCode>
1625       UNDEFINED_RESULT_CODES = new ConcurrentHashMap<Integer,ResultCode>(10);
1626
1627
1628
1629  /**
1630   * The serial version UID for this serializable class.
1631   */
1632  private static final long serialVersionUID = 7609311304252378100L;
1633
1634
1635
1636  // The integer value for this result code.
1637  private final int intValue;
1638
1639  // The name for this result code.
1640  private final String name;
1641
1642  // The string representation for this result code.
1643  private final String stringRepresentation;
1644
1645
1646
1647  /**
1648   * Creates a new result code with the specified integer value.
1649   *
1650   * @param  intValue  The integer value for this result code.
1651   */
1652  private ResultCode(final int intValue)
1653  {
1654    this.intValue = intValue;
1655
1656    name                 = String.valueOf(intValue);
1657    stringRepresentation = name;
1658  }
1659
1660
1661
1662  /**
1663   * Creates a new result code with the specified name and integer value.
1664   *
1665   * @param  name      The name for this result code.
1666   * @param  intValue  The integer value for this result code.
1667   */
1668  private ResultCode(final String name, final int intValue)
1669  {
1670    this.name     = name;
1671    this.intValue = intValue;
1672
1673    stringRepresentation = intValue + " (" + name + ')';
1674  }
1675
1676
1677
1678  /**
1679   * Retrieves the name for this result code.
1680   *
1681   * @return  The name for this result code.
1682   */
1683  public String getName()
1684  {
1685    return name;
1686  }
1687
1688
1689
1690  /**
1691   * Retrieves the integer value for this result code.
1692   *
1693   * @return  The integer value for this result code.
1694   */
1695  public int intValue()
1696  {
1697    return intValue;
1698  }
1699
1700
1701
1702  /**
1703   * Retrieves the result code with the specified integer value.  If the
1704   * provided integer value does not correspond to a predefined
1705   * {@code ResultCode} object, then a new {@code ResultCode} object will be
1706   * created and returned.  Any new result codes created will also be cached
1707   * and returned for any subsequent requests with that integer value so the
1708   * same object will always be returned for a given integer value.
1709   *
1710   * @param  intValue  The integer value for which to retrieve the corresponding
1711   *                   result code.
1712   *
1713   * @return  The result code with the specified integer value, or a new result
1714   *          code
1715   */
1716  public static ResultCode valueOf(final int intValue)
1717  {
1718    return valueOf(intValue, null);
1719  }
1720
1721
1722
1723  /**
1724   * Retrieves the result code with the specified integer value.  If the
1725   * provided integer value does not correspond to a predefined
1726   * {@code ResultCode} object, then a new {@code ResultCode} object will be
1727   * created and returned.  Any new result codes created will also be cached
1728   * and returned for any subsequent requests with that integer value so the
1729   * same object will always be returned for a given integer value.
1730   *
1731   * @param  intValue  The integer value for which to retrieve the corresponding
1732   *                   result code.
1733   * @param  name      The user-friendly name to use for the result code if no
1734   *                   result code has been previously accessed with the same
1735   *                   integer value.  It may be {@code null} if this is not
1736   *                   known or a string representation of the integer value
1737   *                   should be used.
1738   *
1739   * @return  The result code with the specified integer value, or a new result
1740   *          code
1741   */
1742  public static ResultCode valueOf(final int intValue, final String name)
1743  {
1744    switch (intValue)
1745    {
1746      case SUCCESS_INT_VALUE:
1747        return SUCCESS;
1748      case OPERATIONS_ERROR_INT_VALUE:
1749        return OPERATIONS_ERROR;
1750      case PROTOCOL_ERROR_INT_VALUE:
1751        return PROTOCOL_ERROR;
1752      case TIME_LIMIT_EXCEEDED_INT_VALUE:
1753        return TIME_LIMIT_EXCEEDED;
1754      case SIZE_LIMIT_EXCEEDED_INT_VALUE:
1755        return SIZE_LIMIT_EXCEEDED;
1756      case COMPARE_FALSE_INT_VALUE:
1757        return COMPARE_FALSE;
1758      case COMPARE_TRUE_INT_VALUE:
1759        return COMPARE_TRUE;
1760      case AUTH_METHOD_NOT_SUPPORTED_INT_VALUE:
1761        return AUTH_METHOD_NOT_SUPPORTED;
1762      case STRONG_AUTH_REQUIRED_INT_VALUE:
1763        return STRONG_AUTH_REQUIRED;
1764      case REFERRAL_INT_VALUE:
1765        return REFERRAL;
1766      case ADMIN_LIMIT_EXCEEDED_INT_VALUE:
1767        return ADMIN_LIMIT_EXCEEDED;
1768      case UNAVAILABLE_CRITICAL_EXTENSION_INT_VALUE:
1769        return UNAVAILABLE_CRITICAL_EXTENSION;
1770      case CONFIDENTIALITY_REQUIRED_INT_VALUE:
1771        return CONFIDENTIALITY_REQUIRED;
1772      case SASL_BIND_IN_PROGRESS_INT_VALUE:
1773        return SASL_BIND_IN_PROGRESS;
1774      case NO_SUCH_ATTRIBUTE_INT_VALUE:
1775        return NO_SUCH_ATTRIBUTE;
1776      case UNDEFINED_ATTRIBUTE_TYPE_INT_VALUE:
1777        return UNDEFINED_ATTRIBUTE_TYPE;
1778      case INAPPROPRIATE_MATCHING_INT_VALUE:
1779        return INAPPROPRIATE_MATCHING;
1780      case CONSTRAINT_VIOLATION_INT_VALUE:
1781        return CONSTRAINT_VIOLATION;
1782      case ATTRIBUTE_OR_VALUE_EXISTS_INT_VALUE:
1783        return ATTRIBUTE_OR_VALUE_EXISTS;
1784      case INVALID_ATTRIBUTE_SYNTAX_INT_VALUE:
1785        return INVALID_ATTRIBUTE_SYNTAX;
1786      case NO_SUCH_OBJECT_INT_VALUE:
1787        return NO_SUCH_OBJECT;
1788      case ALIAS_PROBLEM_INT_VALUE:
1789        return ALIAS_PROBLEM;
1790      case INVALID_DN_SYNTAX_INT_VALUE:
1791        return INVALID_DN_SYNTAX;
1792      case ALIAS_DEREFERENCING_PROBLEM_INT_VALUE:
1793        return ALIAS_DEREFERENCING_PROBLEM;
1794      case INAPPROPRIATE_AUTHENTICATION_INT_VALUE:
1795        return INAPPROPRIATE_AUTHENTICATION;
1796      case INVALID_CREDENTIALS_INT_VALUE:
1797        return INVALID_CREDENTIALS;
1798      case INSUFFICIENT_ACCESS_RIGHTS_INT_VALUE:
1799        return INSUFFICIENT_ACCESS_RIGHTS;
1800      case BUSY_INT_VALUE:
1801        return BUSY;
1802      case UNAVAILABLE_INT_VALUE:
1803        return UNAVAILABLE;
1804      case UNWILLING_TO_PERFORM_INT_VALUE:
1805        return UNWILLING_TO_PERFORM;
1806      case LOOP_DETECT_INT_VALUE:
1807        return LOOP_DETECT;
1808      case SORT_CONTROL_MISSING_INT_VALUE:
1809        return SORT_CONTROL_MISSING;
1810      case OFFSET_RANGE_ERROR_INT_VALUE:
1811        return OFFSET_RANGE_ERROR;
1812      case NAMING_VIOLATION_INT_VALUE:
1813        return NAMING_VIOLATION;
1814      case OBJECT_CLASS_VIOLATION_INT_VALUE:
1815        return OBJECT_CLASS_VIOLATION;
1816      case NOT_ALLOWED_ON_NONLEAF_INT_VALUE:
1817        return NOT_ALLOWED_ON_NONLEAF;
1818      case NOT_ALLOWED_ON_RDN_INT_VALUE:
1819        return NOT_ALLOWED_ON_RDN;
1820      case ENTRY_ALREADY_EXISTS_INT_VALUE:
1821        return ENTRY_ALREADY_EXISTS;
1822      case OBJECT_CLASS_MODS_PROHIBITED_INT_VALUE:
1823        return OBJECT_CLASS_MODS_PROHIBITED;
1824      case AFFECTS_MULTIPLE_DSAS_INT_VALUE:
1825        return AFFECTS_MULTIPLE_DSAS;
1826      case VIRTUAL_LIST_VIEW_ERROR_INT_VALUE:
1827        return VIRTUAL_LIST_VIEW_ERROR;
1828      case OTHER_INT_VALUE:
1829        return OTHER;
1830      case SERVER_DOWN_INT_VALUE:
1831        return SERVER_DOWN;
1832      case LOCAL_ERROR_INT_VALUE:
1833        return LOCAL_ERROR;
1834      case ENCODING_ERROR_INT_VALUE:
1835        return ENCODING_ERROR;
1836      case DECODING_ERROR_INT_VALUE:
1837        return DECODING_ERROR;
1838      case TIMEOUT_INT_VALUE:
1839        return TIMEOUT;
1840      case AUTH_UNKNOWN_INT_VALUE:
1841        return AUTH_UNKNOWN;
1842      case FILTER_ERROR_INT_VALUE:
1843        return FILTER_ERROR;
1844      case USER_CANCELED_INT_VALUE:
1845        return USER_CANCELED;
1846      case PARAM_ERROR_INT_VALUE:
1847        return PARAM_ERROR;
1848      case NO_MEMORY_INT_VALUE:
1849        return NO_MEMORY;
1850      case CONNECT_ERROR_INT_VALUE:
1851        return CONNECT_ERROR;
1852      case NOT_SUPPORTED_INT_VALUE:
1853        return NOT_SUPPORTED;
1854      case CONTROL_NOT_FOUND_INT_VALUE:
1855        return CONTROL_NOT_FOUND;
1856      case NO_RESULTS_RETURNED_INT_VALUE:
1857        return NO_RESULTS_RETURNED;
1858      case MORE_RESULTS_TO_RETURN_INT_VALUE:
1859        return MORE_RESULTS_TO_RETURN;
1860      case CLIENT_LOOP_INT_VALUE:
1861        return CLIENT_LOOP;
1862      case REFERRAL_LIMIT_EXCEEDED_INT_VALUE:
1863        return REFERRAL_LIMIT_EXCEEDED;
1864      case CANCELED_INT_VALUE:
1865        return CANCELED;
1866      case NO_SUCH_OPERATION_INT_VALUE:
1867        return NO_SUCH_OPERATION;
1868      case TOO_LATE_INT_VALUE:
1869        return TOO_LATE;
1870      case CANNOT_CANCEL_INT_VALUE:
1871        return CANNOT_CANCEL;
1872      case ASSERTION_FAILED_INT_VALUE:
1873        return ASSERTION_FAILED;
1874      case AUTHORIZATION_DENIED_INT_VALUE:
1875        return AUTHORIZATION_DENIED;
1876      case E_SYNC_REFRESH_REQUIRED_INT_VALUE:
1877        return E_SYNC_REFRESH_REQUIRED;
1878      case NO_OPERATION_INT_VALUE:
1879        return NO_OPERATION;
1880      case INTERACTIVE_TRANSACTION_ABORTED_INT_VALUE:
1881        return INTERACTIVE_TRANSACTION_ABORTED;
1882      case DATABASE_LOCK_CONFLICT_INT_VALUE:
1883        return DATABASE_LOCK_CONFLICT;
1884      case MIRRORED_SUBTREE_DIGEST_MISMATCH_INT_VALUE:
1885        return MIRRORED_SUBTREE_DIGEST_MISMATCH;
1886      case TOKEN_DELIVERY_MECHANISM_UNAVAILABLE_INT_VALUE:
1887        return TOKEN_DELIVERY_MECHANISM_UNAVAILABLE;
1888      case TOKEN_DELIVERY_ATTEMPT_FAILED_INT_VALUE:
1889        return TOKEN_DELIVERY_ATTEMPT_FAILED;
1890      case TOKEN_DELIVERY_INVALID_RECIPIENT_ID_INT_VALUE:
1891        return TOKEN_DELIVERY_INVALID_RECIPIENT_ID;
1892      case TOKEN_DELIVERY_INVALID_ACCOUNT_STATE_INT_VALUE:
1893        return TOKEN_DELIVERY_INVALID_ACCOUNT_STATE;
1894    }
1895
1896    ResultCode rc = UNDEFINED_RESULT_CODES.get(intValue);
1897    if (rc == null)
1898    {
1899      if (name == null)
1900      {
1901        rc = new ResultCode(intValue);
1902      }
1903      else
1904      {
1905        rc = new ResultCode(name, intValue);
1906      }
1907
1908      final ResultCode existingRC =
1909           UNDEFINED_RESULT_CODES.putIfAbsent(intValue, rc);
1910      if (existingRC != null)
1911      {
1912        return existingRC;
1913      }
1914    }
1915
1916    return rc;
1917  }
1918
1919
1920
1921  /**
1922   * Retrieves an array of all result codes defined in the LDAP SDK.  This will
1923   * not include dynamically-generated values.
1924   *
1925   * @return  An array of all result codes defined in the LDAP SDK.
1926   */
1927  public static ResultCode[] values()
1928  {
1929    return new ResultCode[]
1930    {
1931      SUCCESS,
1932      OPERATIONS_ERROR,
1933      PROTOCOL_ERROR,
1934      TIME_LIMIT_EXCEEDED,
1935      SIZE_LIMIT_EXCEEDED,
1936      COMPARE_FALSE,
1937      COMPARE_TRUE,
1938      AUTH_METHOD_NOT_SUPPORTED,
1939      STRONG_AUTH_REQUIRED,
1940      REFERRAL,
1941      ADMIN_LIMIT_EXCEEDED,
1942      UNAVAILABLE_CRITICAL_EXTENSION,
1943      CONFIDENTIALITY_REQUIRED,
1944      SASL_BIND_IN_PROGRESS,
1945      NO_SUCH_ATTRIBUTE,
1946      UNDEFINED_ATTRIBUTE_TYPE,
1947      INAPPROPRIATE_MATCHING,
1948      CONSTRAINT_VIOLATION,
1949      ATTRIBUTE_OR_VALUE_EXISTS,
1950      INVALID_ATTRIBUTE_SYNTAX,
1951      NO_SUCH_OBJECT,
1952      ALIAS_PROBLEM,
1953      INVALID_DN_SYNTAX,
1954      ALIAS_DEREFERENCING_PROBLEM,
1955      INAPPROPRIATE_AUTHENTICATION,
1956      INVALID_CREDENTIALS,
1957      INSUFFICIENT_ACCESS_RIGHTS,
1958      BUSY,
1959      UNAVAILABLE,
1960      UNWILLING_TO_PERFORM,
1961      LOOP_DETECT,
1962      SORT_CONTROL_MISSING,
1963      OFFSET_RANGE_ERROR,
1964      NAMING_VIOLATION,
1965      OBJECT_CLASS_VIOLATION,
1966      NOT_ALLOWED_ON_NONLEAF,
1967      NOT_ALLOWED_ON_RDN,
1968      ENTRY_ALREADY_EXISTS,
1969      OBJECT_CLASS_MODS_PROHIBITED,
1970      AFFECTS_MULTIPLE_DSAS,
1971      VIRTUAL_LIST_VIEW_ERROR,
1972      OTHER,
1973      SERVER_DOWN,
1974      LOCAL_ERROR,
1975      ENCODING_ERROR,
1976      DECODING_ERROR,
1977      TIMEOUT,
1978      AUTH_UNKNOWN,
1979      FILTER_ERROR,
1980      USER_CANCELED,
1981      PARAM_ERROR,
1982      NO_MEMORY,
1983      CONNECT_ERROR,
1984      NOT_SUPPORTED,
1985      CONTROL_NOT_FOUND,
1986      NO_RESULTS_RETURNED,
1987      MORE_RESULTS_TO_RETURN,
1988      CLIENT_LOOP,
1989      REFERRAL_LIMIT_EXCEEDED,
1990      CANCELED,
1991      NO_SUCH_OPERATION,
1992      TOO_LATE,
1993      CANNOT_CANCEL,
1994      ASSERTION_FAILED,
1995      AUTHORIZATION_DENIED,
1996      E_SYNC_REFRESH_REQUIRED,
1997      NO_OPERATION,
1998      INTERACTIVE_TRANSACTION_ABORTED,
1999      DATABASE_LOCK_CONFLICT,
2000      MIRRORED_SUBTREE_DIGEST_MISMATCH,
2001      TOKEN_DELIVERY_MECHANISM_UNAVAILABLE,
2002      TOKEN_DELIVERY_ATTEMPT_FAILED,
2003      TOKEN_DELIVERY_INVALID_RECIPIENT_ID,
2004      TOKEN_DELIVERY_INVALID_ACCOUNT_STATE
2005    };
2006  }
2007
2008
2009
2010  /**
2011   * Indicates whether this result code is one that should be used for
2012   * client-side errors rather than returned by the server.
2013   *
2014   * @return  {@code true} if this result code is a client-side result code, or
2015   *          {@code false} if it is one that may be returned by the server.
2016   */
2017  public boolean isClientSideResultCode()
2018  {
2019    return isClientSideResultCode(this);
2020  }
2021
2022
2023
2024  /**
2025   * Indicates whether the provided result code is one that should be used for
2026   * client-side errors rather than returned by the server.
2027   *
2028   * @param  resultCode  The result code for which to make the determination.
2029   *
2030   * @return  {@code true} if the provided result code is a client-side result
2031   *          code, or {@code false} if it is one that may be returned by the
2032   *          server.
2033   */
2034  public static boolean isClientSideResultCode(final ResultCode resultCode)
2035  {
2036    switch (resultCode.intValue())
2037    {
2038      case SERVER_DOWN_INT_VALUE:
2039      case LOCAL_ERROR_INT_VALUE:
2040      case ENCODING_ERROR_INT_VALUE:
2041      case DECODING_ERROR_INT_VALUE:
2042      case TIMEOUT_INT_VALUE:
2043      case AUTH_UNKNOWN_INT_VALUE:
2044      case FILTER_ERROR_INT_VALUE:
2045      case USER_CANCELED_INT_VALUE:
2046      case PARAM_ERROR_INT_VALUE:
2047      case NO_MEMORY_INT_VALUE:
2048      case CONNECT_ERROR_INT_VALUE:
2049      case NOT_SUPPORTED_INT_VALUE:
2050      case CONTROL_NOT_FOUND_INT_VALUE:
2051      case NO_RESULTS_RETURNED_INT_VALUE:
2052      case MORE_RESULTS_TO_RETURN_INT_VALUE:
2053      case CLIENT_LOOP_INT_VALUE:
2054      case REFERRAL_LIMIT_EXCEEDED_INT_VALUE:
2055        return true;
2056      default:
2057        return false;
2058    }
2059  }
2060
2061
2062
2063  /**
2064   * Indicates whether the connection on which this result code was received is
2065   * likely still usable.  Note that this is a best guess, and it may or may not
2066   * be correct.  It will attempt to be conservative so that a connection is
2067   * more likely to be classified as unusable when it may still be valid than to
2068   * be classified as usable when that is no longer the case.
2069   *
2070   * @return  {@code true} if it is likely that the connection on which this
2071   *          result code was received is still usable, or {@code false} if it
2072   *          may no longer be valid.
2073   */
2074  public boolean isConnectionUsable()
2075  {
2076    return isConnectionUsable(this);
2077  }
2078
2079
2080
2081  /**
2082   * Indicates whether the connection on which the provided result code was
2083   * received is likely still usable.  Note that this is a best guess based on
2084   * the provided result code, and it may or may not be correct.  It will
2085   * attempt to be conservative so that a connection is more likely to be
2086   * classified as unusable when it may still be valid than to be classified
2087   * as usable when that is no longer the case.
2088   *
2089   * @param  resultCode  The result code for which to make the determination.
2090   *
2091   * @return  {@code true} if it is likely that the connection on which the
2092   *          provided result code was received is still usable, or
2093   *          {@code false} if it may no longer be valid.
2094   */
2095  public static boolean isConnectionUsable(final ResultCode resultCode)
2096  {
2097    switch (resultCode.intValue())
2098    {
2099      case OPERATIONS_ERROR_INT_VALUE:
2100      case PROTOCOL_ERROR_INT_VALUE:
2101      case BUSY_INT_VALUE:
2102      case UNAVAILABLE_INT_VALUE:
2103      case UNWILLING_TO_PERFORM_INT_VALUE:
2104      case OTHER_INT_VALUE:
2105      case SERVER_DOWN_INT_VALUE:
2106      case LOCAL_ERROR_INT_VALUE:
2107      case ENCODING_ERROR_INT_VALUE:
2108      case DECODING_ERROR_INT_VALUE:
2109      case TIMEOUT_INT_VALUE:
2110      case NO_MEMORY_INT_VALUE:
2111      case CONNECT_ERROR_INT_VALUE:
2112        return false;
2113      default:
2114        return true;
2115    }
2116  }
2117
2118
2119
2120  /**
2121   * The hash code for this result code.
2122   *
2123   * @return  The hash code for this result code.
2124   */
2125  @Override()
2126  public int hashCode()
2127  {
2128    return intValue;
2129  }
2130
2131
2132
2133  /**
2134   * Indicates whether the provided object is equal to this result code.
2135   *
2136   * @param  o  The object for which to make the determination.
2137   *
2138   * @return  {@code true} if the provided object is a result code that is equal
2139   *          to this result code, or {@code false} if not.
2140   */
2141  @Override()
2142  public boolean equals(final Object o)
2143  {
2144    if (o == null)
2145    {
2146      return false;
2147    }
2148    else if (o == this)
2149    {
2150      return true;
2151    }
2152    else if (o instanceof ResultCode)
2153    {
2154      return (intValue == ((ResultCode) o).intValue);
2155    }
2156    else
2157    {
2158      return false;
2159    }
2160  }
2161
2162
2163
2164  /**
2165   * Retrieves a string representation of this result code.
2166   *
2167   * @return  A string representation of this result code.
2168   */
2169  @Override()
2170  public String toString()
2171  {
2172    return stringRepresentation;
2173  }
2174}