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