001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2006-2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.types;
028 import org.opends.messages.Message;
029
030
031 import org.opends.server.protocols.ldap.LDAPResultCode;
032
033 import static org.opends.messages.CoreMessages.*;
034
035
036
037 /**
038 * This enumeration defines the set of possible result codes that may
039 * be used for providing clients with information about result of
040 * processing an operation.
041 */
042 @org.opends.server.types.PublicAPI(
043 stability=org.opends.server.types.StabilityLevel.UNCOMMITTED,
044 mayInstantiate=false,
045 mayExtend=false,
046 mayInvoke=true)
047 public enum ResultCode
048 {
049 /**
050 * The result code that should only be used if the actual result
051 * code has not yet been determined.
052 */
053 UNDEFINED(-1, null),
054
055
056
057 /**
058 * The result code that indicates that the operation completed
059 * successfully.
060 */
061 SUCCESS(LDAPResultCode.SUCCESS, INFO_RESULT_SUCCESS.get()),
062
063
064
065 /**
066 * The result code that indicates that an internal error prevented
067 * the operation from being processed properly.
068 */
069 OPERATIONS_ERROR(LDAPResultCode.OPERATIONS_ERROR,
070 INFO_RESULT_OPERATIONS_ERROR.get()),
071
072
073
074 /**
075 * The result code that indicates that the client sent a malformed
076 * or illegal request to the server.
077 */
078 PROTOCOL_ERROR(LDAPResultCode.PROTOCOL_ERROR,
079 INFO_RESULT_PROTOCOL_ERROR.get()),
080
081
082
083 /**
084 * The result code that indicates that a time limit was exceeded
085 * while attempting to process the request.
086 */
087 TIME_LIMIT_EXCEEDED(LDAPResultCode.TIME_LIMIT_EXCEEDED,
088 INFO_RESULT_TIME_LIMIT_EXCEEDED.get()),
089
090
091
092 /**
093 * The result code that indicates that a size limit was exceeded
094 * while attempting to process the request.
095 */
096 SIZE_LIMIT_EXCEEDED(LDAPResultCode.SIZE_LIMIT_EXCEEDED,
097 INFO_RESULT_SIZE_LIMIT_EXCEEDED.get()),
098
099
100
101 /**
102 * The result code that indicates that the attribute value assertion
103 * included in a compare request did not match the targeted entry.
104 */
105 COMPARE_FALSE(LDAPResultCode.COMPARE_FALSE,
106 INFO_RESULT_COMPARE_FALSE.get()),
107
108
109
110 /**
111 * The result code that indicates that the attribute value assertion
112 * included in a compare request did match the targeted entry.
113 */
114 COMPARE_TRUE(LDAPResultCode.COMPARE_TRUE,
115 INFO_RESULT_COMPARE_TRUE.get()),
116
117
118
119 /**
120 * The result code that indicates that the requested authentication
121 * attempt failed because it referenced an invalid SASL mechanism.
122 */
123 AUTH_METHOD_NOT_SUPPORTED(LDAPResultCode.AUTH_METHOD_NOT_SUPPORTED,
124 INFO_RESULT_AUTH_METHOD_NOT_SUPPORTED.get()),
125
126
127
128 /**
129 * The result code that indicates that the requested operation could
130 * not be processed because it requires that the client has
131 * completed a strong form of authentication.
132 */
133 STRONG_AUTH_REQUIRED(LDAPResultCode.STRONG_AUTH_REQUIRED,
134 INFO_RESULT_STRONG_AUTH_REQUIRED.get()),
135
136
137
138 /**
139 * The result code that indicates that a referral was encountered.
140 */
141 REFERRAL(LDAPResultCode.REFERRAL, INFO_RESULT_REFERRAL.get()),
142
143
144
145 /**
146 * The result code that indicates that processing on the requested
147 * operation could not continue because an administrative limit was
148 * exceeded.
149 */
150 ADMIN_LIMIT_EXCEEDED(LDAPResultCode.ADMIN_LIMIT_EXCEEDED,
151 INFO_RESULT_ADMIN_LIMIT_EXCEEDED.get()),
152
153
154
155 /**
156 * The result code that indicates that the requested operation
157 * failed because it included a critical extension that is
158 * unsupported or inappropriate for that request.
159 */
160 UNAVAILABLE_CRITICAL_EXTENSION(
161 LDAPResultCode.UNAVAILABLE_CRITICAL_EXTENSION,
162 INFO_RESULT_UNAVAILABLE_CRITICAL_EXTENSION.get()),
163
164
165
166 /**
167 * The result code that indicates that the requested operation could
168 * not be processed because it requires confidentiality for the
169 * communication between the client and the server.
170 */
171 CONFIDENTIALITY_REQUIRED(LDAPResultCode.CONFIDENTIALITY_REQUIRED,
172 INFO_RESULT_CONFIDENTIALITY_REQUIRED.get()),
173
174
175
176 /**
177 * The result code that should be used for intermediate responses in
178 * multi-stage SASL bind operations.
179 */
180 SASL_BIND_IN_PROGRESS(LDAPResultCode.SASL_BIND_IN_PROGRESS,
181 INFO_RESULT_SASL_BIND_IN_PROGRESS.get()),
182
183
184
185 /**
186 * The result code that indicates that the requested operation
187 * failed because it targeted an attribute or attribute value that
188 * did not exist in the specified entry.
189 */
190 NO_SUCH_ATTRIBUTE(LDAPResultCode.NO_SUCH_ATTRIBUTE,
191 INFO_RESULT_NO_SUCH_ATTRIBUTE.get()),
192
193
194
195 /**
196 * The result code that indicates that the requested operation
197 * failed because it referenced an attribute that is not defined in
198 * the server schema.
199 */
200 UNDEFINED_ATTRIBUTE_TYPE(LDAPResultCode.UNDEFINED_ATTRIBUTE_TYPE,
201 INFO_RESULT_UNDEFINED_ATTRIBUTE_TYPE.get()),
202
203
204
205 /**
206 * The result code that indicates that the requested operation
207 * failed because it attempted to perform an inappropriate type of
208 * matching against an attribute.
209 */
210 INAPPROPRIATE_MATCHING(LDAPResultCode.INAPPROPRIATE_MATCHING,
211 INFO_RESULT_INAPPROPRIATE_MATCHING.get()),
212
213
214
215 /**
216 * The result code that indicates that the requested operation
217 * failed because it would have violated some constraint defined in
218 * the server.
219 */
220 CONSTRAINT_VIOLATION(LDAPResultCode.CONSTRAINT_VIOLATION,
221 INFO_RESULT_CONSTRAINT_VIOLATION.get()),
222
223
224
225 /**
226 * The result code that indicates that the requested operation
227 * failed because it would have resulted in a conflict with an
228 * existing attribute or attribute value in the target entry.
229 */
230 ATTRIBUTE_OR_VALUE_EXISTS(LDAPResultCode.ATTRIBUTE_OR_VALUE_EXISTS,
231 INFO_RESULT_ATTRIBUTE_OR_VALUE_EXISTS.get()),
232
233
234
235 /**
236 * The result code that indicates that the requested operation
237 * failed because it violated the syntax for a specified attribute.
238 */
239 INVALID_ATTRIBUTE_SYNTAX(LDAPResultCode.INVALID_ATTRIBUTE_SYNTAX,
240 INFO_RESULT_INVALID_ATTRIBUTE_SYNTAX.get()),
241
242
243
244 /**
245 * The result code that indicates that the requested operation
246 * failed because it referenced an entry that does not exist.
247 */
248 NO_SUCH_OBJECT(LDAPResultCode.NO_SUCH_OBJECT,
249 INFO_RESULT_NO_SUCH_OBJECT.get()),
250
251
252
253 /**
254 * The result code that indicates that the requested operation
255 * failed because it attempted to perform an illegal operation on an
256 * alias.
257 */
258 ALIAS_PROBLEM(LDAPResultCode.ALIAS_PROBLEM,
259 INFO_RESULT_ALIAS_PROBLEM.get()),
260
261
262
263 /**
264 * The result code that indicates that the requested operation
265 * failed because it would have resulted in an entry with an invalid
266 * or malformed DN.
267 */
268 INVALID_DN_SYNTAX(LDAPResultCode.INVALID_DN_SYNTAX,
269 INFO_RESULT_INVALID_DN_SYNTAX.get()),
270
271
272
273 /**
274 * The result code that indicates that a problem was encountered
275 * while attempting to dereference an alias for a search operation.
276 */
277 ALIAS_DEREFERENCING_PROBLEM(
278 LDAPResultCode.ALIAS_DEREFERENCING_PROBLEM,
279 INFO_RESULT_ALIAS_DEREFERENCING_PROBLEM.get()),
280
281
282
283 /**
284 * The result code that indicates that an authentication attempt
285 * failed because the requested type of authentication was not
286 * appropriate for the targeted entry.
287 */
288 INAPPROPRIATE_AUTHENTICATION(
289 LDAPResultCode.INAPPROPRIATE_AUTHENTICATION,
290 INFO_RESULT_INAPPROPRIATE_AUTHENTICATION.get()),
291
292
293
294 /**
295 * The result code that indicates that an authentication attempt
296 * failed because the user did not provide a valid set of
297 * credentials.
298 */
299 INVALID_CREDENTIALS(LDAPResultCode.INVALID_CREDENTIALS,
300 INFO_RESULT_INVALID_CREDENTIALS.get()),
301
302
303
304 /**
305 * The result code that indicates that the client does not have
306 * sufficient permission to perform the requested operation.
307 */
308 INSUFFICIENT_ACCESS_RIGHTS(
309 LDAPResultCode.INSUFFICIENT_ACCESS_RIGHTS,
310 INFO_RESULT_INSUFFICIENT_ACCESS_RIGHTS.get()),
311
312
313
314 /**
315 * The result code that indicates that the server is too busy to
316 * process the requested operation.
317 */
318 BUSY(LDAPResultCode.BUSY, INFO_RESULT_BUSY.get()),
319
320
321
322 /**
323 * The result code that indicates that either the entire server or
324 * one or more required resources were not available for use in
325 * processing the request.
326 */
327 UNAVAILABLE(LDAPResultCode.UNAVAILABLE,
328 INFO_RESULT_UNAVAILABLE.get()),
329
330
331
332 /**
333 * The result code that indicates that the server is unwilling to
334 * perform the requested operation.
335 */
336 UNWILLING_TO_PERFORM(LDAPResultCode.UNWILLING_TO_PERFORM,
337 INFO_RESULT_UNWILLING_TO_PERFORM.get()),
338
339
340
341 /**
342 * The result code that indicates that a referral or chaining
343 * loop was detected while processing the request.
344 */
345 LOOP_DETECT(LDAPResultCode.LOOP_DETECT,
346 INFO_RESULT_LOOP_DETECT.get()),
347
348
349
350 /**
351 * The result code that indicates that a search request included a
352 * VLV request control without a server-side sort control.
353 */
354 SORT_CONTROL_MISSING(LDAPResultCode.SORT_CONTROL_MISSING,
355 INFO_RESULT_SORT_CONTROL_MISSING.get()),
356
357
358
359 /**
360 * The result code that indicates that a search request included a
361 * VLV request control with an invalid offset.
362 */
363 OFFSET_RANGE_ERROR(LDAPResultCode.OFFSET_RANGE_ERROR,
364 INFO_RESULT_OFFSET_RANGE_ERROR.get()),
365
366
367
368 /**
369 * The result code that indicates that the requested operation
370 * failed because it would have violated the server's naming
371 * configuration.
372 */
373 NAMING_VIOLATION(LDAPResultCode.NAMING_VIOLATION,
374 INFO_RESULT_NAMING_VIOLATION.get()),
375
376
377
378 /**
379 * The result code that indicates that the requested operation
380 * failed because it would have resulted in an entry that violated
381 * the server schema.
382 */
383 OBJECTCLASS_VIOLATION(LDAPResultCode.OBJECTCLASS_VIOLATION,
384 INFO_RESULT_OBJECTCLASS_VIOLATION.get()),
385
386
387
388 /**
389 * The result code that indicates that the requested operation is
390 * not allowed for non-leaf entries.
391 */
392 NOT_ALLOWED_ON_NONLEAF(LDAPResultCode.NOT_ALLOWED_ON_NONLEAF,
393 INFO_RESULT_NOT_ALLOWED_ON_NONLEAF.get()),
394
395
396
397 /**
398 * The result code that indicates that the requested operation is
399 * not allowed on an RDN attribute.
400 */
401 NOT_ALLOWED_ON_RDN(LDAPResultCode.NOT_ALLOWED_ON_RDN,
402 INFO_RESULT_NOT_ALLOWED_ON_RDN.get()),
403
404
405
406 /**
407 * The result code that indicates that the requested operation
408 * failed because it would have resulted in an entry that conflicts
409 * with an entry that already exists.
410 */
411 ENTRY_ALREADY_EXISTS(LDAPResultCode.ENTRY_ALREADY_EXISTS,
412 INFO_RESULT_ENTRY_ALREADY_EXISTS.get()),
413
414
415
416 /**
417 * The result code that indicates that the operation could not be
418 * processed because it would have modified the objectclasses
419 * associated with an entry in an illegal manner.
420 */
421 OBJECTCLASS_MODS_PROHIBITED(
422 LDAPResultCode.OBJECTCLASS_MODS_PROHIBITED,
423 INFO_RESULT_OBJECTCLASS_MODS_PROHIBITED.get()),
424
425
426
427 /**
428 * The result code that indicates that the operation could not be
429 * processed because it would impact multiple DSAs or other
430 * repositories.
431 */
432 AFFECTS_MULTIPLE_DSAS(LDAPResultCode.AFFECTS_MULTIPLE_DSAS,
433 INFO_RESULT_AFFECTS_MULTIPLE_DSAS.get()),
434
435
436
437 /**
438 * The result code that indicates that the operation could not be
439 * processed because there was an error while processing the virtual
440 * list view control.
441 */
442 VIRTUAL_LIST_VIEW_ERROR(LDAPResultCode.VIRTUAL_LIST_VIEW_ERROR,
443 INFO_RESULT_VIRTUAL_LIST_VIEW_ERROR.get()),
444
445
446
447 /**
448 * The result code that should be used if no other result code is
449 * appropriate.
450 */
451 OTHER(LDAPResultCode.OTHER, INFO_RESULT_OTHER.get()),
452
453
454
455 /**
456 * The client-side result code that should be used if an established
457 * connection is lost. This should not be used over protocol.
458 */
459 CLIENT_SIDE_SERVER_DOWN(LDAPResultCode.CLIENT_SIDE_SERVER_DOWN,
460 INFO_RESULT_CLIENT_SIDE_SERVER_DOWN.get()),
461
462
463
464 /**
465 * The client-side result code that should be used if a local
466 * (client-side) error occurs. This should not be used over
467 * protocol.
468 */
469 CLIENT_SIDE_LOCAL_ERROR(LDAPResultCode.CLIENT_SIDE_LOCAL_ERROR,
470 INFO_RESULT_CLIENT_SIDE_LOCAL_ERROR.get()),
471
472
473
474 /**
475 * The client-side result code that should be used if an error
476 * occurs while encoding a request. This should not be used over
477 * protocol.
478 */
479 CLIENT_SIDE_ENCODING_ERROR(
480 LDAPResultCode.CLIENT_SIDE_ENCODING_ERROR,
481 INFO_RESULT_CLIENT_SIDE_ENCODING_ERROR.get()),
482
483
484
485 /**
486 * The client-side result code that should be used if an error
487 * occurs while decoding a response. This should not be used over
488 * protocol.
489 */
490 CLIENT_SIDE_DECODING_ERROR(
491 LDAPResultCode.CLIENT_SIDE_DECODING_ERROR,
492 INFO_RESULT_CLIENT_SIDE_DECODING_ERROR.get()),
493
494
495
496 /**
497 * The client-side result code that should be used if a client-side
498 * timeout occurs. This should not be used over protocol.
499 */
500 CLIENT_SIDE_TIMEOUT(LDAPResultCode.CLIENT_SIDE_TIMEOUT,
501 INFO_RESULT_CLIENT_SIDE_TIMEOUT.get()),
502
503
504
505 /**
506 * The client-side result code that should be used if an unknown or
507 * unsupported authentication mechanism is requested. This should
508 * not be used over protocol.
509 */
510 CLIENT_SIDE_AUTH_UNKNOWN(LDAPResultCode.CLIENT_SIDE_AUTH_UNKNOWN,
511 INFO_RESULT_CLIENT_SIDE_AUTH_UNKNOWN.get()),
512
513
514
515 /**
516 * The client-side result code that should be used if a malformed
517 * search filter is provided. This should not be used over
518 * protocol.
519 */
520 CLIENT_SIDE_FILTER_ERROR(LDAPResultCode.CLIENT_SIDE_FILTER_ERROR,
521 INFO_RESULT_CLIENT_SIDE_FILTER_ERROR.get()),
522
523
524
525 /**
526 * The client-side result code that should be used if a user
527 * cancelled a client-side operation. This should not be used over
528 * protocol.
529 */
530 CLIENT_SIDE_USER_CANCELLED(
531 LDAPResultCode.CLIENT_SIDE_USER_CANCELLED,
532 INFO_RESULT_CLIENT_SIDE_USER_CANCELLED.get()),
533
534
535
536 /**
537 * The client-side result code that should be used if there was an
538 * error in the parameter(s) provided. This should not be used over
539 * protocol.
540 */
541 CLIENT_SIDE_PARAM_ERROR(LDAPResultCode.CLIENT_SIDE_PARAM_ERROR,
542 INFO_RESULT_CLIENT_SIDE_PARAM_ERROR.get()),
543
544
545
546 /**
547 * The client-side result code that should be used if the client
548 * cannot obtain enough memory to perform the requested operation.
549 * This should not be used over protocol.
550 */
551 CLIENT_SIDE_NO_MEMORY(LDAPResultCode.CLIENT_SIDE_NO_MEMORY,
552 INFO_RESULT_CLIENT_SIDE_NO_MEMORY.get()),
553
554
555
556 /**
557 * The client-side result code that should be used if a connection
558 * cannot be established. This should not be used over protocol.
559 */
560 CLIENT_SIDE_CONNECT_ERROR(LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR,
561 INFO_RESULT_CLIENT_SIDE_CONNECT_ERROR.get()),
562
563
564
565 /**
566 * The client-side result code that should be used if a user
567 * requests an unsupported operation. This should not be used over
568 * protocol.
569 */
570 CLIENT_SIDE_NOT_SUPPORTED(LDAPResultCode.CLIENT_SIDE_NOT_SUPPORTED,
571 INFO_RESULT_CLIENT_SIDE_NOT_SUPPORTED.get()),
572
573
574
575 /**
576 * The client-side result code that should be used if an expected
577 * control is not found in a response. This should not be used over
578 * protocol.
579 */
580 CLIENT_SIDE_CONTROL_NOT_FOUND(
581 LDAPResultCode.CLIENT_SIDE_CONTROL_NOT_FOUND,
582 INFO_RESULT_CLIENT_SIDE_CONTROL_NOT_FOUND.get()),
583
584
585
586 /**
587 * The client-side result code that should be used if no results
588 * were returned for a search operation that expected them. This
589 * should not be used over protocol.
590 */
591 CLIENT_SIDE_NO_RESULTS_RETURNED(
592 LDAPResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED,
593 INFO_RESULT_CLIENT_SIDE_NO_RESULTS_RETURNED.get()),
594
595
596
597 /**
598 * The client-side result code that should be used if there are more
599 * results to be processed. This should not be used over protocol.
600 */
601 CLIENT_SIDE_MORE_RESULTS_TO_RETURN(
602 LDAPResultCode.CLIENT_SIDE_MORE_RESULTS_TO_RETURN,
603 INFO_RESULT_CLIENT_SIDE_MORE_RESULTS_TO_RETURN.get()),
604
605
606
607 /**
608 * The client-side result code that should be used if a referral
609 * loop is detected. This should not be used over protocol.
610 */
611 CLIENT_SIDE_CLIENT_LOOP(LDAPResultCode.CLIENT_SIDE_CLIENT_LOOP,
612 INFO_RESULT_CLIENT_SIDE_CLIENT_LOOP.get()),
613
614
615
616 /**
617 * The client-side result code that should be used if the referral
618 * hop limit was exceeded. This should not be used over protocol.
619 */
620 CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED(
621 LDAPResultCode.CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED,
622 INFO_RESULT_CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED.get()),
623
624
625
626 /**
627 * The result code that indicates that a cancel request was
628 * successful, or that the specified operation was canceled.
629 */
630 CANCELED(LDAPResultCode.CANCELED, INFO_RESULT_CANCELED.get()),
631
632
633
634 /**
635 * The result code that indicates that a cancel request was
636 * unsuccessful because the targeted operation did not exist or had
637 * already completed.
638 */
639 NO_SUCH_OPERATION(LDAPResultCode.NO_SUCH_OPERATION,
640 INFO_RESULT_NO_SUCH_OPERATION.get()),
641
642
643
644 /**
645 * The result code that indicates that a cancel request was
646 * unsuccessful because processing on the targeted operation had
647 * already reached a point at which it could not be canceled.
648 */
649 TOO_LATE(LDAPResultCode.TOO_LATE, INFO_RESULT_TOO_LATE.get()),
650
651
652
653 /**
654 * The result code that indicates that a cancel request was
655 * unsuccessful because the targeted operation was one that could
656 * not be canceled.
657 */
658 CANNOT_CANCEL(LDAPResultCode.CANNOT_CANCEL,
659 INFO_RESULT_CANNOT_CANCEL.get()),
660
661
662
663 /**
664 * The result code that indicates that the filter contained in an
665 * assertion control failed to match the target entry.
666 */
667 ASSERTION_FAILED(LDAPResultCode.ASSERTION_FAILED,
668 INFO_RESULT_ASSERTION_FAILED.get()),
669
670
671
672 /**
673 * The result code that should be used if the server will not allow
674 * the client to use the requested authorization.
675 */
676 AUTHORIZATION_DENIED(LDAPResultCode.AUTHORIZATION_DENIED,
677 INFO_RESULT_AUTHORIZATION_DENIED.get()),
678
679
680
681 /**
682 * The result code that should be used if the server did not
683 * actually complete processing on the associated operation because
684 * the request included the LDAP No-Op control.
685 */
686 NO_OPERATION(LDAPResultCode.NO_OPERATION,
687 INFO_RESULT_NO_OPERATION.get());
688
689
690
691 // The integer value for this result code.
692 private int intValue;
693
694 // The short human-readable name for this result code.
695 private Message resultCodeName;
696
697
698
699 /**
700 * Creates a new result code with the specified int value and unique
701 * identifier.
702 *
703 * @param intValue The integer value for this result code.
704 * @param name The name for this result code.
705 */
706 private ResultCode(int intValue, Message name)
707 {
708 this.intValue = intValue;
709 this.resultCodeName = name;
710 }
711
712
713
714 /**
715 * Retrieves the integer value for this result code.
716 *
717 * @return The integer value for this result code.
718 */
719 public int getIntValue()
720 {
721 return intValue;
722 }
723
724
725
726 /**
727 * Retrieves the result code with the provided int value.
728 *
729 * @param intValue The value for which to retrieve the
730 * corresponding result code.
731 *
732 * @return The result code with the provided int value, or
733 * <CODE>ResultCode.OTHER</CODE> if there is no recognized
734 * result code with the provided int value.
735 */
736 public static ResultCode valueOf(int intValue)
737 {
738 switch (intValue)
739 {
740 case LDAPResultCode.SUCCESS:
741 return SUCCESS;
742 case LDAPResultCode.OPERATIONS_ERROR:
743 return OPERATIONS_ERROR;
744 case LDAPResultCode.PROTOCOL_ERROR:
745 return PROTOCOL_ERROR;
746 case LDAPResultCode.TIME_LIMIT_EXCEEDED:
747 return TIME_LIMIT_EXCEEDED;
748 case LDAPResultCode.SIZE_LIMIT_EXCEEDED:
749 return SIZE_LIMIT_EXCEEDED;
750 case LDAPResultCode.COMPARE_FALSE:
751 return COMPARE_FALSE;
752 case LDAPResultCode.COMPARE_TRUE:
753 return COMPARE_TRUE;
754 case LDAPResultCode.AUTH_METHOD_NOT_SUPPORTED:
755 return AUTH_METHOD_NOT_SUPPORTED;
756 case LDAPResultCode.STRONG_AUTH_REQUIRED:
757 return STRONG_AUTH_REQUIRED;
758 case LDAPResultCode.REFERRAL:
759 return REFERRAL;
760 case LDAPResultCode.ADMIN_LIMIT_EXCEEDED:
761 return ADMIN_LIMIT_EXCEEDED;
762 case LDAPResultCode.UNAVAILABLE_CRITICAL_EXTENSION:
763 return UNAVAILABLE_CRITICAL_EXTENSION;
764 case LDAPResultCode.CONFIDENTIALITY_REQUIRED:
765 return CONFIDENTIALITY_REQUIRED;
766 case LDAPResultCode.SASL_BIND_IN_PROGRESS:
767 return SASL_BIND_IN_PROGRESS;
768 case LDAPResultCode.NO_SUCH_ATTRIBUTE:
769 return NO_SUCH_ATTRIBUTE;
770 case LDAPResultCode.UNDEFINED_ATTRIBUTE_TYPE:
771 return UNDEFINED_ATTRIBUTE_TYPE;
772 case LDAPResultCode.INAPPROPRIATE_MATCHING:
773 return INAPPROPRIATE_MATCHING;
774 case LDAPResultCode.CONSTRAINT_VIOLATION:
775 return CONSTRAINT_VIOLATION;
776 case LDAPResultCode.ATTRIBUTE_OR_VALUE_EXISTS:
777 return ATTRIBUTE_OR_VALUE_EXISTS;
778 case LDAPResultCode.INVALID_ATTRIBUTE_SYNTAX:
779 return INVALID_ATTRIBUTE_SYNTAX;
780 case LDAPResultCode.NO_SUCH_OBJECT:
781 return NO_SUCH_OBJECT;
782 case LDAPResultCode.ALIAS_PROBLEM:
783 return ALIAS_PROBLEM;
784 case LDAPResultCode.INVALID_DN_SYNTAX:
785 return INVALID_DN_SYNTAX;
786 case LDAPResultCode.ALIAS_DEREFERENCING_PROBLEM:
787 return ALIAS_DEREFERENCING_PROBLEM;
788 case LDAPResultCode.INAPPROPRIATE_AUTHENTICATION:
789 return INAPPROPRIATE_AUTHENTICATION;
790 case LDAPResultCode.INVALID_CREDENTIALS:
791 return INVALID_CREDENTIALS;
792 case LDAPResultCode.INSUFFICIENT_ACCESS_RIGHTS:
793 return INSUFFICIENT_ACCESS_RIGHTS;
794 case LDAPResultCode.BUSY:
795 return BUSY;
796 case LDAPResultCode.UNAVAILABLE:
797 return UNAVAILABLE;
798 case LDAPResultCode.UNWILLING_TO_PERFORM:
799 return UNWILLING_TO_PERFORM;
800 case LDAPResultCode.LOOP_DETECT:
801 return LOOP_DETECT;
802 case LDAPResultCode.SORT_CONTROL_MISSING:
803 return SORT_CONTROL_MISSING;
804 case LDAPResultCode.OFFSET_RANGE_ERROR:
805 return OFFSET_RANGE_ERROR;
806 case LDAPResultCode.NAMING_VIOLATION:
807 return NAMING_VIOLATION;
808 case LDAPResultCode.OBJECTCLASS_VIOLATION:
809 return OBJECTCLASS_VIOLATION;
810 case LDAPResultCode.NOT_ALLOWED_ON_NONLEAF:
811 return NOT_ALLOWED_ON_NONLEAF;
812 case LDAPResultCode.NOT_ALLOWED_ON_RDN:
813 return NOT_ALLOWED_ON_RDN;
814 case LDAPResultCode.ENTRY_ALREADY_EXISTS:
815 return ENTRY_ALREADY_EXISTS;
816 case LDAPResultCode.OBJECTCLASS_MODS_PROHIBITED:
817 return OBJECTCLASS_MODS_PROHIBITED;
818 case LDAPResultCode.AFFECTS_MULTIPLE_DSAS:
819 return AFFECTS_MULTIPLE_DSAS;
820 case LDAPResultCode.VIRTUAL_LIST_VIEW_ERROR:
821 return VIRTUAL_LIST_VIEW_ERROR;
822 case LDAPResultCode.CLIENT_SIDE_SERVER_DOWN:
823 return CLIENT_SIDE_SERVER_DOWN;
824 case LDAPResultCode.CLIENT_SIDE_LOCAL_ERROR:
825 return CLIENT_SIDE_LOCAL_ERROR;
826 case LDAPResultCode.CLIENT_SIDE_ENCODING_ERROR:
827 return CLIENT_SIDE_ENCODING_ERROR;
828 case LDAPResultCode.CLIENT_SIDE_DECODING_ERROR:
829 return CLIENT_SIDE_DECODING_ERROR;
830 case LDAPResultCode.CLIENT_SIDE_TIMEOUT:
831 return CLIENT_SIDE_TIMEOUT;
832 case LDAPResultCode.CLIENT_SIDE_AUTH_UNKNOWN:
833 return CLIENT_SIDE_AUTH_UNKNOWN;
834 case LDAPResultCode.CLIENT_SIDE_FILTER_ERROR:
835 return CLIENT_SIDE_FILTER_ERROR;
836 case LDAPResultCode.CLIENT_SIDE_USER_CANCELLED:
837 return CLIENT_SIDE_USER_CANCELLED;
838 case LDAPResultCode.CLIENT_SIDE_PARAM_ERROR:
839 return CLIENT_SIDE_PARAM_ERROR;
840 case LDAPResultCode.CLIENT_SIDE_NO_MEMORY:
841 return CLIENT_SIDE_NO_MEMORY;
842 case LDAPResultCode.CLIENT_SIDE_CONNECT_ERROR:
843 return CLIENT_SIDE_CONNECT_ERROR;
844 case LDAPResultCode.CLIENT_SIDE_NOT_SUPPORTED:
845 return CLIENT_SIDE_NOT_SUPPORTED;
846 case LDAPResultCode.CLIENT_SIDE_CONTROL_NOT_FOUND:
847 return CLIENT_SIDE_CONTROL_NOT_FOUND;
848 case LDAPResultCode.CLIENT_SIDE_NO_RESULTS_RETURNED:
849 return CLIENT_SIDE_NO_RESULTS_RETURNED;
850 case LDAPResultCode.CLIENT_SIDE_MORE_RESULTS_TO_RETURN:
851 return CLIENT_SIDE_MORE_RESULTS_TO_RETURN;
852 case LDAPResultCode.CLIENT_SIDE_CLIENT_LOOP:
853 return CLIENT_SIDE_CLIENT_LOOP;
854 case LDAPResultCode.CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED:
855 return CLIENT_SIDE_REFERRAL_LIMIT_EXCEEDED;
856 case LDAPResultCode.CANCELED:
857 return CANCELED;
858 case LDAPResultCode.NO_SUCH_OPERATION:
859 return NO_SUCH_OPERATION;
860 case LDAPResultCode.TOO_LATE:
861 return TOO_LATE;
862 case LDAPResultCode.CANNOT_CANCEL:
863 return CANNOT_CANCEL;
864 case LDAPResultCode.ASSERTION_FAILED:
865 return ASSERTION_FAILED;
866 case LDAPResultCode.AUTHORIZATION_DENIED:
867 return AUTHORIZATION_DENIED;
868 case LDAPResultCode.NO_OPERATION:
869 // FIXME -- We will also need to handle the official result
870 // code when it is allocated.
871 return NO_OPERATION;
872 default:
873 return ResultCode.OTHER;
874 }
875 }
876
877
878
879 /**
880 * Retrieves the short human-readable name for this result code.
881 *
882 * @return The short human-readable name for this result code.
883 */
884 public Message getResultCodeName()
885 {
886 return resultCodeName;
887 }
888
889
890
891 /**
892 * Retrieves a string representation of this result code.
893 *
894 * @return A string representation of this result code.
895 */
896 public String toString()
897 {
898 return resultCodeName != null ? resultCodeName.toString() : null;
899 }
900 }
901