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