1 /* 2 Copyright 2002-2006 Martin van den Bemt 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 /* ==================================================================== 17 * The Apache Software License, Version 1.1 18 * 19 * Copyright (c) 2002-2003 The Apache Software Foundation. All rights 20 * reserved. 21 * 22 * Redistribution and use in source and binary forms, with or without 23 * modification, are permitted provided that the following conditions 24 * are met: 25 * 26 * 1. Redistributions of source code must retain the above copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 29 * 2. Redistributions in binary form must reproduce the above copyright 30 * notice, this list of conditions and the following disclaimer in 31 * the documentation and/or other materials provided with the 32 * distribution. 33 * 34 * 3. The end-user documentation included with the redistribution, if 35 * any, must include the following acknowledgement: 36 * "This product includes software developed by the 37 * Apache Software Foundation (http://www.apache.org/)." 38 * Alternately, this acknowledgement may appear in the software itself, 39 * if and wherever such third-party acknowledgements normally appear. 40 * 41 * 4. The names "The Jakarta Project", "Commons", and "Apache Software 42 * Foundation" must not be used to endorse or promote products derived 43 * from this software without prior written permission. For written 44 * permission, please contact apache@apache.org. 45 * 46 * 5. Products derived from this software may not be called "Apache" 47 * nor may "Apache" appear in their names without prior written 48 * permission of the Apache Software Foundation. 49 * 50 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 51 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 52 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 53 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR 54 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 57 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 58 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 59 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 60 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 * ==================================================================== 63 * 64 * This software consists of voluntary contributions made by many 65 * individuals on behalf of the Apache Software Foundation. For more 66 * information on the Apache Software Foundation, please see 67 * <http://www.apache.org/>. 68 */ 69 package org.xulux.utils; 70 71 /** 72 * This class is a copy of BooleanUtils from jakarta commons lang, version 73 * 1.17. This is to replace the dependency of complete jakarta commons lang 74 * see http://jakarta.apache.org/commons/lang for the complete lang package. 75 * 76 * <p>Operations on boolean primitives and Boolean objects.</p> 77 * 78 * <p>This class tries to handle <code>null</code> input gracefully. 79 * An exception will not be thrown for a <code>null</code> input. 80 * Each method documents its behaviour in more detail.</p> 81 * 82 * @author Stephen Colebourne 83 * @author Matthew Hawthorne 84 * @author Gary Gregory 85 * @author Martin van den Bemt 86 * @since 2.0 87 * @version $Id: BooleanUtils.java,v 1.1 2005/12/18 12:58:15 mvdb Exp $ 88 */ 89 public class BooleanUtils { 90 91 /** Reusable Integer constant for zero. */ 92 public static final Integer INTEGER_ZERO = new Integer(0); 93 /** Reusable Integer constant for one. */ 94 public static final Integer INTEGER_ONE = new Integer(1); 95 96 /** 97 * <p><code>BooleanUtils</code> instances should NOT be constructed in standard programming. 98 * Instead, the class should be used as <code>BooleanUtils.toBooleanObject(true);</code>.</p> 99 * 100 * <p>This constructor is public to permit tools that require a JavaBean instance 101 * to operate.</p> 102 */ 103 public BooleanUtils() { 104 } 105 106 // Boolean utilities 107 //-------------------------------------------------------------------------- 108 /** 109 * <p>Negates the specified boolean.</p> 110 * 111 * <p>If <code>null</code> is passed in, <code>null</code> will be returned.</p> 112 * 113 * <pre> 114 * BooleanUtils.negate(Boolean.TRUE) = Boolean.FALSE; 115 * BooleanUtils.negate(Boolean.FALSE) = Boolean.TRUE; 116 * BooleanUtils.negate(null) = null; 117 * </pre> 118 * 119 * @param bool the Boolean to negate, may be null 120 * @return the negated Boolean, or <code>null</code> if <code>null</code> input 121 */ 122 public static Boolean negate(Boolean bool) { 123 if (bool == null) { 124 return null; 125 } 126 return (bool.booleanValue() ? Boolean.FALSE : Boolean.TRUE); 127 } 128 129 // boolean Boolean methods 130 //----------------------------------------------------------------------- 131 /** 132 * <p>Boolean factory that avoids creating new Boolean objecs all the time.</p> 133 * 134 * <p>This method was added to JDK1.4 but is available here for earlier JDKs.</p> 135 * 136 * <pre> 137 * BooleanUtils.toBooleanObject(false) = Boolean.FALSE 138 * BooleanUtils.toBooleanObject(true) = Boolean.TRUE 139 * </pre> 140 * 141 * @param bool the boolean to convert 142 * @return Boolean.TRUE or Boolean.FALSE as appropriate 143 */ 144 public static Boolean toBooleanObject(boolean bool) { 145 return (bool ? Boolean.TRUE : Boolean.FALSE); 146 } 147 148 /** 149 * <p>Converts a Boolean to a boolean handling <code>null</code> 150 * by returning <code>false</code>.</p> 151 * 152 * <pre> 153 * BooleanUtils.toBoolean(Boolean.TRUE) = true 154 * BooleanUtils.toBoolean(Boolean.FALSE) = false 155 * BooleanUtils.toBoolean(null) = false 156 * </pre> 157 * 158 * @param bool the boolean to convert 159 * @return <code>true</code> or <code>false</code>, 160 * <code>null</code> returns <code>false</code> 161 */ 162 public static boolean toBoolean(Boolean bool) { 163 if (bool == null) { 164 return false; 165 } 166 return (bool.booleanValue() ? true : false); 167 } 168 169 /** 170 * <p>Converts a Boolean to a boolean handling <code>null</code>.</p> 171 * 172 * <pre> 173 * BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false) = true 174 * BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true) = false 175 * BooleanUtils.toBooleanDefaultIfNull(null, true) = true 176 * </pre> 177 * 178 * @param bool the boolean to convert 179 * @param valueIfNull the boolean value to return if <code>null</code> 180 * @return <code>true</code> or <code>false</code> 181 */ 182 public static boolean toBooleanDefaultIfNull(Boolean bool, boolean valueIfNull) { 183 if (bool == null) { 184 return valueIfNull; 185 } 186 return (bool.booleanValue() ? true : false); 187 } 188 189 // Integer to Boolean methods 190 //----------------------------------------------------------------------- 191 /** 192 * <p>Converts an int to a boolean using the convention that <code>zero</code> 193 * is <code>false</code>.</p> 194 * 195 * <pre> 196 * BooleanUtils.toBoolean(0) = false 197 * BooleanUtils.toBoolean(1) = true 198 * BooleanUtils.toBoolean(2) = true 199 * </pre> 200 * 201 * @param value the int to convert 202 * @return <code>true</code> if non-zero, <code>false</code> 203 * if zero 204 */ 205 public static boolean toBoolean(int value) { 206 return (value == 0 ? false : true); 207 } 208 209 /** 210 * <p>Converts an int to a Boolean using the convention that <code>zero</code> 211 * is <code>false</code>.</p> 212 * 213 * <pre> 214 * BooleanUtils.toBoolean(0) = Boolean.FALSE 215 * BooleanUtils.toBoolean(1) = Boolean.TRUE 216 * BooleanUtils.toBoolean(2) = Boolean.TRUE 217 * </pre> 218 * 219 * @param value the int to convert 220 * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero, 221 * <code>null</code> if <code>null</code> 222 */ 223 public static Boolean toBooleanObject(int value) { 224 return (value == 0 ? Boolean.FALSE : Boolean.TRUE); 225 } 226 227 /** 228 * <p>Converts an Integer to a Boolean using the convention that <code>zero</code> 229 * is <code>false</code>.</p> 230 * 231 * <p><code>null</code> will be converted to <code>null</code>.</p> 232 * 233 * <pre> 234 * BooleanUtils.toBoolean(new Integer(0)) = Boolean.FALSE 235 * BooleanUtils.toBoolean(new Integer(1)) = Boolean.TRUE 236 * BooleanUtils.toBoolean(new Integer(null)) = null 237 * </pre> 238 * 239 * @param value the Integer to convert 240 * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero, 241 * <code>null</code> if <code>null</code> input 242 */ 243 public static Boolean toBooleanObject(Integer value) { 244 if (value == null) { 245 return null; 246 } 247 return (value.intValue() == 0 ? Boolean.FALSE : Boolean.TRUE); 248 } 249 250 /** 251 * <p>Converts an int to a boolean specifying the conversion values.</p> 252 * 253 * <pre> 254 * BooleanUtils.toBoolean(0, 1, 0) = false 255 * BooleanUtils.toBoolean(1, 1, 0) = true 256 * BooleanUtils.toBoolean(2, 1, 2) = false 257 * BooleanUtils.toBoolean(2, 2, 0) = true 258 * </pre> 259 * 260 * @param value the Integer to convert 261 * @param trueValue the value to match for <code>true</code> 262 * @param falseValue the value to match for <code>false</code> 263 * @return <code>true</code> or <code>false</code> 264 * @throws IllegalArgumentException if no match 265 */ 266 public static boolean toBoolean(int value, int trueValue, int falseValue) { 267 if (value == trueValue) { 268 return true; 269 } else if (value == falseValue) { 270 return false; 271 } 272 // no match 273 throw new IllegalArgumentException("The Integer did not match either specified value"); 274 } 275 276 /** 277 * <p>Converts an Integer to a boolean specifying the conversion values.</p> 278 * 279 * <pre> 280 * BooleanUtils.toBoolean(new Integer(0), new Integer(1), new Integer(0)) = false 281 * BooleanUtils.toBoolean(new Integer(1), new Integer(1), new Integer(0)) = true 282 * BooleanUtils.toBoolean(new Integer(2), new Integer(1), new Integer(2)) = false 283 * BooleanUtils.toBoolean(new Integer(2), new Integer(2), new Integer(0)) = true 284 * BooleanUtils.toBoolean(null, null, new Integer(0)) = true 285 * </pre> 286 * 287 * @param value the Integer to convert 288 * @param trueValue the value to match for <code>true</code>, 289 * may be <code>null</code> 290 * @param falseValue the value to match for <code>false</code>, 291 * may be <code>null</code> 292 * @return <code>true</code> or <code>false</code> 293 * @throws IllegalArgumentException if no match 294 */ 295 public static boolean toBoolean(Integer value, Integer trueValue, Integer falseValue) { 296 if (value == null) { 297 if (trueValue == null) { 298 return true; 299 } else if (falseValue == null) { 300 return false; 301 } 302 } else if (value.equals(trueValue)) { 303 return true; 304 } else if (value.equals(falseValue)) { 305 return false; 306 } 307 // no match 308 throw new IllegalArgumentException("The Integer did not match either specified value"); 309 } 310 311 /** 312 * <p>Converts an int to a Boolean specifying the conversion values.</p> 313 * 314 * <pre> 315 * BooleanUtils.toBooleanObject(0, 0, 2, 3) = Boolean.TRUE 316 * BooleanUtils.toBooleanObject(2, 1, 2, 3) = Boolean.FALSE 317 * BooleanUtils.toBooleanObject(3, 1, 2, 3) = null 318 * </pre> 319 * 320 * @param value the Integer to convert 321 * @param trueValue the value to match for <code>true</code> 322 * @param falseValue the value to match for <code>false</code> 323 * @param nullValue the value to to match for <code>null</code> 324 * @return Boolean.TRUE, Boolean.FALSE, or <code>null</code> 325 * @throws IllegalArgumentException if no match 326 */ 327 public static Boolean toBooleanObject(int value, int trueValue, int falseValue, int nullValue) { 328 if (value == trueValue) { 329 return Boolean.TRUE; 330 } else if (value == falseValue) { 331 return Boolean.FALSE; 332 } else if (value == nullValue) { 333 return null; 334 } 335 // no match 336 throw new IllegalArgumentException("The Integer did not match any specified value"); 337 } 338 339 /** 340 * <p>Converts an Integer to a Boolean specifying the conversion values.</p> 341 * 342 * <pre> 343 * BooleanUtils.toBooleanObject(new Integer(0), new Integer(0), new Integer(2), new Integer(3)) = Boolean.TRUE 344 * BooleanUtils.toBooleanObject(new Integer(2), new Integer(1), new Integer(2), new Integer(3)) = Boolean.FALSE 345 * BooleanUtils.toBooleanObject(new Integer(3), new Integer(1), new Integer(2), new Integer(3)) = null 346 * </pre> 347 * 348 * @param value the Integer to convert 349 * @param trueValue the value to match for <code>true</code>, 350 * may be <code>null</code> 351 * @param falseValue the value to match for <code>false</code>, 352 * may be <code>null</code> 353 * @param nullValue the value to to match for <code>null</code>, 354 * may be <code>null</code> 355 * @return Boolean.TRUE, Boolean.FALSE, or <code>null</code> 356 * @throws IllegalArgumentException if no match 357 */ 358 public static Boolean toBooleanObject(Integer value, Integer trueValue, Integer falseValue, Integer nullValue) { 359 if (value == null) { 360 if (trueValue == null) { 361 return Boolean.TRUE; 362 } else if (falseValue == null) { 363 return Boolean.FALSE; 364 } else if (nullValue == null) { 365 return null; 366 } 367 } else if (value.equals(trueValue)) { 368 return Boolean.TRUE; 369 } else if (value.equals(falseValue)) { 370 return Boolean.FALSE; 371 } else if (value.equals(nullValue)) { 372 return null; 373 } 374 // no match 375 throw new IllegalArgumentException("The Integer did not match any specified value"); 376 } 377 378 // Boolean to Integer methods 379 //----------------------------------------------------------------------- 380 /** 381 * <p>Converts a boolean to an int using the convention that 382 * <code>zero</code> is <code>false</code>.</p> 383 * 384 * <pre> 385 * BooleanUtils.toInteger(true) = 1 386 * BooleanUtils.toInteger(false) = 0 387 * </pre> 388 * 389 * @param bool the boolean to convert 390 * @return one if <code>true</code>, zero if <code>false</code> 391 */ 392 public static int toInteger(boolean bool) { 393 return (bool ? 1 : 0); 394 } 395 396 /** 397 * <p>Converts a boolean to an Integer using the convention that 398 * <code>zero</code> is <code>false</code>.</p> 399 * 400 * <pre> 401 * BooleanUtils.toIntegerObject(true) = new Integer(1) 402 * BooleanUtils.toIntegerObject(false) = new Integer(0) 403 * </pre> 404 * 405 * @param bool the boolean to convert 406 * @return one if <code>true</code>, zero if <code>false</code> 407 */ 408 public static Integer toIntegerObject(boolean bool) { 409 return (bool ? INTEGER_ONE : INTEGER_ZERO); 410 } 411 412 /** 413 * <p>Converts a Boolean to a Integer using the convention that 414 * <code>zero</code> is <code>false</code>.</p> 415 * 416 * <p><code>null</code> will be converted to <code>null</code>.</p> 417 * 418 * <pre> 419 * BooleanUtils.toIntegerObject(Boolean.TRUE) = new Integer(1) 420 * BooleanUtils.toIntegerObject(Boolean.FALSE) = new Integer(0) 421 * </pre> 422 * 423 * @param bool the Boolean to convert 424 * @return one if Boolean.TRUE, zero if Boolean.FALSE, <code>null</code> if <code>null</code> 425 */ 426 public static Integer toIntegerObject(Boolean bool) { 427 if (bool == null) { 428 return null; 429 } 430 return (bool.booleanValue() ? INTEGER_ONE : INTEGER_ZERO); 431 } 432 433 /** 434 * <p>Converts a boolean to an int specifying the conversion values.</p> 435 * 436 * <pre> 437 * BooleanUtils.toInteger(true, 1, 0) = 1 438 * BooleanUtils.toInteger(false, 1, 0) = 0 439 * </pre> 440 * 441 * @param bool the to convert 442 * @param trueValue the value to return if <code>true</code> 443 * @param falseValue the value to return if <code>false</code> 444 * @return the appropriate value 445 */ 446 public static int toInteger(boolean bool, int trueValue, int falseValue) { 447 return (bool ? trueValue : falseValue); 448 } 449 450 /** 451 * <p>Converts a Boolean to an int specifying the conversion values.</p> 452 * 453 * <pre> 454 * BooleanUtils.toInteger(Boolean.TRUE, 1, 0, 2) = 1 455 * BooleanUtils.toInteger(Boolean.FALSE, 1, 0, 2) = 0 456 * BooleanUtils.toInteger(null, 1, 0, 2) = 2 457 * </pre> 458 * 459 * @param bool the Boolean to convert 460 * @param trueValue the value to return if <code>true</code> 461 * @param falseValue the value to return if <code>false</code> 462 * @param nullValue the value to return if <code>null</code> 463 * @return the appropriate value 464 */ 465 public static int toInteger(Boolean bool, int trueValue, int falseValue, int nullValue) { 466 if (bool == null) { 467 return nullValue; 468 } 469 return (bool.booleanValue() ? trueValue : falseValue); 470 } 471 472 /** 473 * <p>Converts a boolean to an Integer specifying the conversion values.</p> 474 * 475 * <pre> 476 * BooleanUtils.toIntegerObject(true, new Integer(1), new Integer(0)) = new Integer(1) 477 * BooleanUtils.toIntegerObject(false, new Integer(1), new Integer(0)) = new Integer(0) 478 * </pre> 479 * 480 * @param bool the to convert 481 * @param trueValue the value to return if <code>true</code>, 482 * may be <code>null</code> 483 * @param falseValue the value to return if <code>false</code>, 484 * may be <code>null</code> 485 * @return the appropriate value 486 */ 487 public static Integer toIntegerObject(boolean bool, Integer trueValue, Integer falseValue) { 488 return (bool ? trueValue : falseValue); 489 } 490 491 /** 492 * <p>Converts a Boolean to an Integer specifying the conversion values.</p> 493 * 494 * <pre> 495 * BooleanUtils.toIntegerObject(Boolean.TRUE, new Integer(1), new Integer(0), new Integer(2)) = new Integer(1) 496 * BooleanUtils.toIntegerObject(Boolean.FALSE, new Integer(1), new Integer(0), new Integer(2)) = new Integer(0) 497 * BooleanUtils.toIntegerObject(null, new Integer(1), new Integer(0), new Integer(2)) = new Integer(2) 498 * </pre> 499 * 500 * @param bool the Boolean to convert 501 * @param trueValue the value to return if <code>true</code>, 502 * may be <code>null</code> 503 * @param falseValue the value to return if <code>false</code>, 504 * may be <code>null</code> 505 * @param nullValue the value to return if <code>null</code>, 506 * may be <code>null</code> 507 * @return the appropriate value 508 */ 509 public static Integer toIntegerObject(Boolean bool, Integer trueValue, Integer falseValue, Integer nullValue) { 510 if (bool == null) { 511 return nullValue; 512 } 513 return (bool.booleanValue() ? trueValue : falseValue); 514 } 515 516 // String to Boolean methods 517 //----------------------------------------------------------------------- 518 /** 519 * <p>Converts a String to a Boolean.</p> 520 * 521 * <p><code>'true'</code>, <code>'on'</code> or <code>'yes'</code> 522 * (case insensitive) will return <code>true</code>. 523 * <code>'false'</code>, <code>'off'</code> or <code>'no'</code> 524 * (case insensitive) will return <code>false</code>. 525 * Otherwise, <code>null</code> is returned.</p> 526 * 527 * <pre> 528 * BooleanUtils.toBooleanObject(null) = null 529 * BooleanUtils.toBooleanObject("true") = Boolean.TRUE 530 * BooleanUtils.toBooleanObject("false") = Boolean.FALSE 531 * BooleanUtils.toBooleanObject("on") = Boolean.TRUE 532 * BooleanUtils.toBooleanObject("ON") = Boolean.TRUE 533 * BooleanUtils.toBooleanObject("off") = Boolean.FALSE 534 * BooleanUtils.toBooleanObject("oFf") = Boolean.FALSE 535 * BooleanUtils.toBooleanObject("blue") = null 536 * </pre> 537 * 538 * @param str the String to check 539 * @return the Boolean value of the string, 540 * <code>null</code> if no match or <code>null</code> input 541 */ 542 public static Boolean toBooleanObject(String str) { 543 if ("true".equalsIgnoreCase(str)) { 544 return Boolean.TRUE; 545 } else if ("false".equalsIgnoreCase(str)) { 546 return Boolean.FALSE; 547 } else if ("on".equalsIgnoreCase(str)) { 548 return Boolean.TRUE; 549 } else if ("off".equalsIgnoreCase(str)) { 550 return Boolean.FALSE; 551 } else if ("yes".equalsIgnoreCase(str)) { 552 return Boolean.TRUE; 553 } else if ("no".equalsIgnoreCase(str)) { 554 return Boolean.FALSE; 555 } 556 // no match 557 return null; 558 } 559 560 /** 561 * <p>Converts a String to a Boolean throwing an exception if no match.</p> 562 * 563 * <pre> 564 * BooleanUtils.toBooleanObject("true", "true", "false", "null") = Boolean.TRUE 565 * BooleanUtils.toBooleanObject("false", "true", "false", "null") = Boolean.FALSE 566 * BooleanUtils.toBooleanObject("null", "true", "false", "null") = null 567 * </pre> 568 * 569 * @param str the String to check 570 * @param trueString the String to match for <code>true</code> 571 * (case sensitive), may be <code>null</code> 572 * @param falseString the String to match for <code>false</code> 573 * (case sensitive), may be <code>null</code> 574 * @param nullString the String to match for <code>null</code> 575 * (case sensitive), may be <code>null</code> 576 * @return the Boolean value of the string, 577 * <code>null</code> if no match or <code>null</code> input 578 */ 579 public static Boolean toBooleanObject(String str, String trueString, String falseString, String nullString) { 580 if (str == null) { 581 if (trueString == null) { 582 return Boolean.TRUE; 583 } else if (falseString == null) { 584 return Boolean.FALSE; 585 } else if (nullString == null) { 586 return null; 587 } 588 } else if (str.equals(trueString)) { 589 return Boolean.TRUE; 590 } else if (str.equals(falseString)) { 591 return Boolean.FALSE; 592 } else if (str.equals(nullString)) { 593 return null; 594 } 595 // no match 596 throw new IllegalArgumentException("The String did not match any specified value"); 597 } 598 599 // String to boolean methods 600 //----------------------------------------------------------------------- 601 /** 602 * <p>Converts a String to a boolean (optimised for performance).</p> 603 * 604 * <p><code>'true'</code>, <code>'on'</code> or <code>'yes'</code> 605 * (case insensitive) will return <code>true</code>. Otherwise, 606 * <code>false</code> is returned.</p> 607 * 608 * <p>This method performs 4 times faster (JDK1.4) than 609 * <code>Boolean.valueOf(String)</code>. However, this method accepts 610 * 'on' and 'yes' as true values. 611 * 612 * <pre> 613 * BooleanUtils.toBoolean(null) = false 614 * BooleanUtils.toBoolean("true") = true 615 * BooleanUtils.toBoolean("TRUE") = true 616 * BooleanUtils.toBoolean("tRUe") = true 617 * BooleanUtils.toBoolean("on") = true 618 * BooleanUtils.toBoolean("yes") = true 619 * BooleanUtils.toBoolean("false") = false 620 * BooleanUtils.toBoolean("x gti") = false 621 * </pre> 622 * 623 * @param str the String to check 624 * @return the boolean value of the string, <code>false</code> if no match 625 */ 626 public static boolean toBoolean(String str) { 627 // Previously used equalsIgnoreCase, which was fast for interned 'true'. 628 // Non interned 'true' matched 15 times slower. 629 // 630 // Optimisation provides same performance as before for interned 'true'. 631 // Similar performance for null, 'false', and other strings not length 2/3/4. 632 // 'true'/'TRUE' match 4 times slower, 'tRUE'/'True' 7 times slower. 633 if (str == "true") { 634 return true; 635 } 636 if (str == null) { 637 return false; 638 } 639 switch (str.length()) { 640 case 2 : 641 { 642 char ch0 = str.charAt(0); 643 char ch1 = str.charAt(1); 644 return (ch0 == 'o' || ch0 == 'O') && (ch1 == 'n' || ch1 == 'N'); 645 } 646 case 3 : 647 { 648 char ch = str.charAt(0); 649 if (ch == 'y') { 650 return (str.charAt(1) == 'e' || str.charAt(1) == 'E') && (str.charAt(2) == 's' || str.charAt(2) == 'S'); 651 } 652 if (ch == 'Y') { 653 return (str.charAt(1) == 'E' || str.charAt(1) == 'e') && (str.charAt(2) == 'S' || str.charAt(2) == 's'); 654 } 655 } 656 case 4 : 657 { 658 char ch = str.charAt(0); 659 if (ch == 't') { 660 return (str.charAt(1) == 'r' || str.charAt(1) == 'R') 661 && (str.charAt(2) == 'u' || str.charAt(2) == 'U') 662 && (str.charAt(3) == 'e' || str.charAt(3) == 'E'); 663 } 664 if (ch == 'T') { 665 return (str.charAt(1) == 'R' || str.charAt(1) == 'r') 666 && (str.charAt(2) == 'U' || str.charAt(2) == 'u') 667 && (str.charAt(3) == 'E' || str.charAt(3) == 'e'); 668 } 669 } 670 } 671 return false; 672 } 673 674 /** 675 * Since xulux works with objects and we don't want to figure 676 * out the type beforehand, we have a stub that is calling 677 * the string and boolean toBoolean methods. 678 * 679 * @param object - if it is null it will return false by default. 680 * @return the restult of the conversion. 681 * @throws IllegalArgumentException - when the type has no booleanconverter. 682 */ 683 public static boolean toBoolean(Object object) { 684 if (object == null) { 685 return false; 686 } 687 if (object instanceof String) { 688 return toBoolean((String) object); 689 } else if (object instanceof Boolean) { 690 return toBoolean((Boolean) object); 691 } else { 692 throw new IllegalArgumentException("Cannot convert to boolean"); 693 } 694 } 695 696 /** 697 * <p>Converts a String to a Boolean throwing an exception if no match found.</p> 698 * 699 * <p>null is returned if there is no match.</p> 700 * 701 * <pre> 702 * BooleanUtils.toBoolean("true", "true", "false") = true 703 * BooleanUtils.toBoolean("false", "true", "false") = false 704 * </pre> 705 * 706 * @param str the String to check 707 * @param trueString the String to match for <code>true</code> 708 * (case sensitive), may be <code>null</code> 709 * @param falseString the String to match for <code>false</code> 710 * (case sensitive), may be <code>null</code> 711 * @return the boolean value of the string 712 * @throws IllegalArgumentException if the String doesn't match 713 */ 714 public static boolean toBoolean(String str, String trueString, String falseString) { 715 if (str == null) { 716 if (trueString == null) { 717 return true; 718 } else if (falseString == null) { 719 return false; 720 } 721 } else if (str.equals(trueString)) { 722 return true; 723 } else if (str.equals(falseString)) { 724 return false; 725 } 726 // no match 727 throw new IllegalArgumentException("The String did not match either specified value"); 728 } 729 730 // Boolean to String methods 731 //----------------------------------------------------------------------- 732 /** 733 * <p>Converts a Boolean to a String returning <code>'true'</code>, 734 * <code>'false'</code>, or <code>null</code>.</p> 735 * 736 * <pre> 737 * BooleanUtils.toStringTrueFalse(Boolean.TRUE) = "true" 738 * BooleanUtils.toStringTrueFalse(Boolean.FALSE) = "false" 739 * BooleanUtils.toStringTrueFalse(null) = null; 740 * </pre> 741 * 742 * @param bool the Boolean to check 743 * @return <code>'true'</code>, <code>'false'</code>, 744 * or <code>null</code> 745 */ 746 public static String toStringTrueFalse(Boolean bool) { 747 return toString(bool, "true", "false", null); 748 } 749 750 /** 751 * <p>Converts a Boolean to a String returning <code>'on'</code>, 752 * <code>'off'</code>, or <code>null</code>.</p> 753 * 754 * <pre> 755 * BooleanUtils.toStringOnOff(Boolean.TRUE) = "on" 756 * BooleanUtils.toStringOnOff(Boolean.FALSE) = "off" 757 * BooleanUtils.toStringOnOff(null) = null; 758 * </pre> 759 * 760 * @param bool the Boolean to check 761 * @return <code>'on'</code>, <code>'off'</code>, 762 * or <code>null</code> 763 */ 764 public static String toStringOnOff(Boolean bool) { 765 return toString(bool, "on", "off", null); 766 } 767 768 /** 769 * <p>Converts a Boolean to a String returning <code>'yes'</code>, 770 * <code>'no'</code>, or <code>null</code>.</p> 771 * 772 * <pre> 773 * BooleanUtils.toStringYesNo(Boolean.TRUE) = "yes" 774 * BooleanUtils.toStringYesNo(Boolean.FALSE) = "no" 775 * BooleanUtils.toStringYesNo(null) = null; 776 * </pre> 777 * 778 * @param bool the Boolean to check 779 * @return <code>'yes'</code>, <code>'no'</code>, 780 * or <code>null</code> 781 */ 782 public static String toStringYesNo(Boolean bool) { 783 return toString(bool, "yes", "no", null); 784 } 785 786 /** 787 * <p>Converts a Boolean to a String returning one of the input Strings.</p> 788 * 789 * <pre> 790 * BooleanUtils.toString(Boolean.TRUE, "true", "false", null) = "true" 791 * BooleanUtils.toString(Boolean.FALSE, "true", "false", null) = "false" 792 * BooleanUtils.toString(null, "true", "false", null) = null; 793 * </pre> 794 * 795 * @param bool the Boolean to check 796 * @param trueString the String to return if <code>true</code>, 797 * may be <code>null</code> 798 * @param falseString the String to return if <code>false</code>, 799 * may be <code>null</code> 800 * @param nullString the String to return if <code>null</code>, 801 * may be <code>null</code> 802 * @return one of the three input Strings 803 */ 804 public static String toString(Boolean bool, String trueString, String falseString, String nullString) { 805 if (bool == null) { 806 return nullString; 807 } 808 return (bool.booleanValue() ? trueString : falseString); 809 } 810 811 // boolean to String methods 812 //----------------------------------------------------------------------- 813 /** 814 * <p>Converts a boolean to a String returning <code>'true'</code> 815 * or <code>'false'</code>.</p> 816 * 817 * <pre> 818 * BooleanUtils.toStringTrueFalse(true) = "true" 819 * BooleanUtils.toStringTrueFalse(false) = "false" 820 * </pre> 821 * 822 * @param bool the Boolean to check 823 * @return <code>'true'</code>, <code>'false'</code>, 824 * or <code>null</code> 825 */ 826 public static String toStringTrueFalse(boolean bool) { 827 return toString(bool, "true", "false"); 828 } 829 830 /** 831 * <p>Converts a boolean to a String returning <code>'on'</code> 832 * or <code>'off'</code>.</p> 833 * 834 * <pre> 835 * BooleanUtils.toStringOnOff(true) = "on" 836 * BooleanUtils.toStringOnOff(false) = "off" 837 * </pre> 838 * 839 * @param bool the Boolean to check 840 * @return <code>'on'</code>, <code>'off'</code>, 841 * or <code>null</code> 842 */ 843 public static String toStringOnOff(boolean bool) { 844 return toString(bool, "on", "off"); 845 } 846 847 /** 848 * <p>Converts a boolean to a String returning <code>'yes'</code> 849 * or <code>'no'</code>.</p> 850 * 851 * <pre> 852 * BooleanUtils.toStringYesNo(true) = "yes" 853 * BooleanUtils.toStringYesNo(false) = "no" 854 * </pre> 855 * 856 * @param bool the Boolean to check 857 * @return <code>'yes'</code>, <code>'no'</code>, 858 * or <code>null</code> 859 */ 860 public static String toStringYesNo(boolean bool) { 861 return toString(bool, "yes", "no"); 862 } 863 864 /** 865 * <p>Converts a boolean to a String returning one of the input Strings.</p> 866 * 867 * <pre> 868 * BooleanUtils.toString(true, "true", "false") = "true" 869 * BooleanUtils.toString(false, "true", "false") = "false" 870 * </pre> 871 * 872 * @param bool the Boolean to check 873 * @param trueString the String to return if <code>true</code>, 874 * may be <code>null</code> 875 * @param falseString the String to return if <code>false</code>, 876 * may be <code>null</code> 877 * @return one of the two input Strings 878 */ 879 public static String toString(boolean bool, String trueString, String falseString) { 880 return (bool ? trueString : falseString); 881 } 882 883 // xor methods 884 // ---------------------------------------------------------------------- 885 /** 886 * <p>Performs an xor on a set of booleans.</p> 887 * 888 * <pre> 889 * BooleanUtils.xor(new boolean[] { true, true }) = false 890 * BooleanUtils.xor(new boolean[] { false, false }) = false 891 * BooleanUtils.xor(new boolean[] { true, false }) = true 892 * </pre> 893 * 894 * @param array an array of <code>boolean<code>s 895 * @return <code>true</code> if the xor is successful. 896 * @throws IllegalArgumentException if <code>array</code> is <code>null</code> 897 * @throws IllegalArgumentException if <code>array</code> is empty. 898 */ 899 public static boolean xor(boolean[] array) { 900 // Validates input 901 if (array == null) { 902 throw new IllegalArgumentException("The Array must not be null"); 903 } else if (array.length == 0) { 904 throw new IllegalArgumentException("Array is empty"); 905 } 906 907 // Loops through array, comparing each item 908 int trueCount = 0; 909 for (int i = 0; i < array.length; i++) { 910 // If item is true, and trueCount is < 1, increments count 911 // Else, xor fails 912 if (array[i]) { 913 if (trueCount < 1) { 914 trueCount++; 915 } else { 916 return false; 917 } 918 } 919 } 920 921 // Returns true if there was exactly 1 true item 922 return trueCount == 1; 923 } 924 }