commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/lang/src/java/org/apache/commons/lang BooleanUtils.java
Date Sun, 15 Dec 2002 16:55:32 GMT
scolebourne    2002/12/15 08:55:32

  Modified:    lang/src/test/org/apache/commons/lang LangTestSuite.java
  Added:       lang/src/test/org/apache/commons/lang BooleanUtilsTest.java
               lang/src/java/org/apache/commons/lang BooleanUtils.java
  Log:
  Add BooleanUtils with lots of boolean conversions
  
  Revision  Changes    Path
  1.7       +2 -1      jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java
  
  Index: LangTestSuite.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- LangTestSuite.java	13 Dec 2002 17:21:56 -0000	1.6
  +++ LangTestSuite.java	15 Dec 2002 16:55:32 -0000	1.7
  @@ -87,6 +87,7 @@
           TestSuite suite = new TestSuite();
           suite.setName("Commons-Lang Tests");
           suite.addTest(ArrayUtilsTest.suite());
  +        suite.addTest(BooleanUtilsTest.suite());
           suite.addTest(CharSetUtilsTest.suite());
           suite.addTest(NumberRangeTest.suite());
           suite.addTest(NumberUtilsTest.suite());
  
  
  
  1.1                  jakarta-commons/lang/src/test/org/apache/commons/lang/BooleanUtilsTest.java
  
  Index: BooleanUtilsTest.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2002 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import junit.textui.TestRunner;
  /**
   * Unit tests {@link org.apache.commons.lang.BooleanUtils}.
   *
   * @author Stephen Colebourne
   * @version $Id: BooleanUtilsTest.java,v 1.1 2002/12/15 16:55:32 scolebourne Exp $
   */
  public class BooleanUtilsTest extends TestCase {
  
      public BooleanUtilsTest(String name) {
          super(name);
      }
  
      public static void main(String[] args) {
          TestRunner.run(suite());
      }
  
      public static Test suite() {
      	TestSuite suite = new TestSuite(BooleanUtilsTest.class);
      	suite.setName("BooleanUtils Tests");
          return suite;
      }
  
      protected void setUp() throws Exception {
          super.setUp();
      }
  
      protected void tearDown() throws Exception {
          super.tearDown();
      }
  
      //-----------------------------------------------------------------------
      public void test_toBooleanObject_boolean() {
          assertSame(Boolean.TRUE, BooleanUtils.toBooleanObject(true));
          assertSame(Boolean.FALSE, BooleanUtils.toBooleanObject(false));
      }
  
      public void test_toBoolean_Boolean() {
          assertEquals(true, BooleanUtils.toBoolean(Boolean.TRUE));
          assertEquals(false, BooleanUtils.toBoolean(Boolean.FALSE));
          assertEquals(false, BooleanUtils.toBoolean((Boolean) null));
      }
  
      public void test_toBooleanDefaultIfNull_Boolean_boolean() {
          assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, true));
          assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false));
          assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true));
          assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, false));
          assertEquals(true, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, true));
          assertEquals(false, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, false));
      }
  
      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      public void test_toBoolean_int() {
          assertEquals(true, BooleanUtils.toBoolean(1));
          assertEquals(true, BooleanUtils.toBoolean(-1));
          assertEquals(false, BooleanUtils.toBoolean(0));
      }
      
      public void test_toBooleanObject_int() {
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(1));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(-1));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(0));
      }
      
      public void test_toBooleanObject_Integer() {
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(1)));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(-1)));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(new Integer(0)));
          assertEquals(null, BooleanUtils.toBooleanObject((Integer) null));
      }
      
      //-----------------------------------------------------------------------
      public void test_toBoolean_int_int_int() {
          assertEquals(true, BooleanUtils.toBoolean(6, 6, 7));
          assertEquals(false, BooleanUtils.toBoolean(7, 6, 7));
          try {
              BooleanUtils.toBoolean(8, 6, 7);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_toBoolean_Integer_Integer_Integer() {
          Integer six = new Integer(6);
          Integer seven = new Integer(7);
          assertEquals(true, BooleanUtils.toBoolean(new Integer(6), six, seven));
          assertEquals(false, BooleanUtils.toBoolean(new Integer(7), six, seven));
          try {
              BooleanUtils.toBoolean(new Integer(8), six, seven);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      //-----------------------------------------------------------------------
      public void test_toBooleanObject_int_int_int() {
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(6, 6, 7, 8));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(7, 6, 7, 8));
          assertEquals(null, BooleanUtils.toBooleanObject(8, 6, 7, 8));
          try {
              BooleanUtils.toBooleanObject(9, 6, 7, 8);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_toBooleanObject_Integer_Integer_Integer() {
          Integer six = new Integer(6);
          Integer seven = new Integer(7);
          Integer eight = new Integer(8);
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(6), six, seven,
eight));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(new Integer(7), six, seven,
eight));
          assertEquals(null, BooleanUtils.toBooleanObject(new Integer(8), six, seven, eight));
          try {
              BooleanUtils.toBooleanObject(new Integer(9), six, seven, eight);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      //-----------------------------------------------------------------------
      public void test_toInteger_boolean() {
          assertEquals(1, BooleanUtils.toInteger(true));
          assertEquals(0, BooleanUtils.toInteger(false));
      }
      
      public void test_toIntegerObject_boolean() {
          assertEquals(new Integer(1), BooleanUtils.toIntegerObject(true));
          assertEquals(new Integer(0), BooleanUtils.toIntegerObject(false));
      }
      
      public void test_toIntegerObject_Boolean() {
          assertEquals(new Integer(1), BooleanUtils.toIntegerObject(Boolean.TRUE));
          assertEquals(new Integer(0), BooleanUtils.toIntegerObject(Boolean.FALSE));
          assertEquals(null, BooleanUtils.toIntegerObject((Boolean) null));
      }
      
      //-----------------------------------------------------------------------
      public void test_toInteger_boolean_int_int() {
          assertEquals(6, BooleanUtils.toInteger(true, 6, 7));
          assertEquals(7, BooleanUtils.toInteger(false, 6, 7));
      }
      
      public void test_toInteger_Boolean_int_int_int() {
          assertEquals(6, BooleanUtils.toInteger(Boolean.TRUE, 6, 7, 8));
          assertEquals(7, BooleanUtils.toInteger(Boolean.FALSE, 6, 7, 8));
          assertEquals(8, BooleanUtils.toInteger(null, 6, 7, 8));
      }
      
      public void test_toIntegerObject_boolean_Integer_Integer() {
          Integer six = new Integer(6);
          Integer seven = new Integer(7);
          assertEquals(six, BooleanUtils.toIntegerObject(true, six, seven));
          assertEquals(seven, BooleanUtils.toIntegerObject(false, six, seven));
      }
      
      public void test_toIntegerObject_Boolean_Integer_Integer_Integer() {
          Integer six = new Integer(6);
          Integer seven = new Integer(7);
          Integer eight = new Integer(8);
          assertEquals(six, BooleanUtils.toIntegerObject(Boolean.TRUE, six, seven, eight));
          assertEquals(seven, BooleanUtils.toIntegerObject(Boolean.FALSE, six, seven, eight));
          assertEquals(eight, BooleanUtils.toIntegerObject((Boolean) null, six, seven, eight));
          assertEquals(null, BooleanUtils.toIntegerObject((Boolean) null, six, seven, null));
      }
      
      //-----------------------------------------------------------------------
      //-----------------------------------------------------------------------
      public void test_toBooleanObject_String() {
          assertEquals(null, BooleanUtils.toBooleanObject((String) null));
          assertEquals(null, BooleanUtils.toBooleanObject(""));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("false"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("no"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("off"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("FALSE"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("NO"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("OFF"));
          assertEquals(null, BooleanUtils.toBooleanObject("oof"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("true"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("yes"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("on"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("TRUE"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("ON"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("YES"));
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("TruE"));
      }
      
      public void test_toBooleanObject_String_String_String_String() {
          assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("Y", "Y", "N", "U"));
          assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("N", "Y", "N", "U"));
          assertEquals(null, BooleanUtils.toBooleanObject("U", "Y", "N", "U"));
          try {
              BooleanUtils.toBooleanObject(null, "Y", "N", "U");
              fail();
          } catch (IllegalArgumentException ex) {}
          try {
              BooleanUtils.toBooleanObject("X", "Y", "N", "U");
              fail();
          } catch (IllegalArgumentException ex) {}
      }
  
      //-----------------------------------------------------------------------
      public void test_toBoolean_String() {
          assertEquals(false, BooleanUtils.toBoolean((String) null));
          assertEquals(false, BooleanUtils.toBoolean(""));
          assertEquals(false, BooleanUtils.toBoolean("off"));
          assertEquals(false, BooleanUtils.toBoolean("oof"));
          assertEquals(true, BooleanUtils.toBoolean("true"));
          assertEquals(true, BooleanUtils.toBoolean("yes"));
          assertEquals(true, BooleanUtils.toBoolean("on"));
          assertEquals(true, BooleanUtils.toBoolean("TRUE"));
          assertEquals(true, BooleanUtils.toBoolean("ON"));
          assertEquals(true, BooleanUtils.toBoolean("YES"));
          assertEquals(true, BooleanUtils.toBoolean("TruE"));
      }
  
      public void test_toBoolean_String_String_String() {
          assertEquals(true, BooleanUtils.toBoolean("Y", "Y", "N"));
          assertEquals(false, BooleanUtils.toBoolean("N", "Y", "N"));
          try {
              BooleanUtils.toBoolean(null, "Y", "N");
              fail();
          } catch (IllegalArgumentException ex) {}
          try {
              BooleanUtils.toBoolean("X", "Y", "N");
              fail();
          } catch (IllegalArgumentException ex) {}
      }
  
      //-----------------------------------------------------------------------
      public void test_toStringTrueFalse_Boolean() {
          assertEquals(null, BooleanUtils.toStringTrueFalse((Boolean) null));
          assertEquals("true", BooleanUtils.toStringTrueFalse(Boolean.TRUE));
          assertEquals("false", BooleanUtils.toStringTrueFalse(Boolean.FALSE));
      }
      
      public void test_toStringOnOff_Boolean() {
          assertEquals(null, BooleanUtils.toStringOnOff((Boolean) null));
          assertEquals("on", BooleanUtils.toStringOnOff(Boolean.TRUE));
          assertEquals("off", BooleanUtils.toStringOnOff(Boolean.FALSE));
      }
      
      public void test_toStringYesNo_Boolean() {
          assertEquals(null, BooleanUtils.toStringYesNo((Boolean) null));
          assertEquals("yes", BooleanUtils.toStringYesNo(Boolean.TRUE));
          assertEquals("no", BooleanUtils.toStringYesNo(Boolean.FALSE));
      }
      
      public void test_toString_Boolean_String_String_String() {
          assertEquals("U", BooleanUtils.toString((Boolean) null, "Y", "N", "U"));
          assertEquals("Y", BooleanUtils.toString(Boolean.TRUE, "Y", "N", "U"));
          assertEquals("N", BooleanUtils.toString(Boolean.FALSE, "Y", "N", "U"));
      }
      
      //-----------------------------------------------------------------------
      public void test_toStringTrueFalse_boolean() {
          assertEquals("true", BooleanUtils.toStringTrueFalse(true));
          assertEquals("false", BooleanUtils.toStringTrueFalse(false));
      }
      
      public void test_toStringOnOff_boolean() {
          assertEquals("on", BooleanUtils.toStringOnOff(true));
          assertEquals("off", BooleanUtils.toStringOnOff(false));
      }
      
      public void test_toStringYesNo_boolean() {
          assertEquals("yes", BooleanUtils.toStringYesNo(true));
          assertEquals("no", BooleanUtils.toStringYesNo(false));
      }
      
      public void test_toString_boolean_String_String_String() {
          assertEquals("Y", BooleanUtils.toString(true, "Y", "N"));
          assertEquals("N", BooleanUtils.toString(false, "Y", "N"));
      }
      
  }
  
  
  
  1.1                  jakarta-commons/lang/src/java/org/apache/commons/lang/BooleanUtils.java
  
  Index: BooleanUtils.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2002 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  /**
   * <p><code>BooleanUtils</code> contains utility methods for working for
   * boolean and Boolean objects.</p>
   *
   * @author Stephen Colebourne
   * @version $Id: BooleanUtils.java,v 1.1 2002/12/15 16:55:32 scolebourne Exp $
   */
  public class BooleanUtils {
  
      /**
       * <p><code>BooleanUtils</code> instances should NOT be constructed
in standard programming.
       * Instead, the class should be used as <code>BooleanUtils.toBooleanObject(true);</code>.</p>
       *
       * <p>This constructor is public to permit tools that require a JavaBean instance
       * to operate.</p>
       */
      public BooleanUtils() {
      }
  
      // boolean Boolean methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Boolean factory that avoids creating new Boolean objecs all the time.</p>
       * 
       * <p>This method was added to JDK1.4 but is available here for earlier JDKs.</p>
       * 
       * @param bool  the boolean to convert
       * @return Boolean.TRUE or Boolean.FALSE as appropriate
       */
      public static Boolean toBooleanObject(boolean bool) {
          return (bool ? Boolean.TRUE : Boolean.FALSE);
      }
      
      /**
       * <p>Converts a Boolean to a boolean handling null by returning false.</p>
       * 
       * @param bool  the boolean to convert
       * @return true or false
       */
      public static boolean toBoolean(Boolean bool) {
          if (bool == null) {
              return false;
          }
          return (bool.booleanValue() ? true : false);
      }
      
      /**
       * <p>Converts a Boolean to a boolean handling null.</p>
       * 
       * @param bool  the boolean to convert
       * @param valueIfNull  the boolean value to return if null
       * @return true or false
       */
      public static boolean toBooleanDefaultIfNull(Boolean bool, boolean valueIfNull) {
          if (bool == null) {
              return valueIfNull;
          }
          return (bool.booleanValue() ? true : false);
      }
      
      // Integer to Boolean methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Convert an int to a boolean using the convention that zero is false.</p>
       * 
       * @param value  the int to convert
       * @return true if non-zero, false if zero
       */
      public static boolean toBoolean(int value) {
          return (value == 0 ? false : true);
      }
      
      /**
       * <p>Convert an int to a Boolean using the convention that zero is false.</p>
       * 
       * @param value  the int to convert
       * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero, null if null
       */
      public static Boolean toBooleanObject(int value) {
          return (value == 0 ? Boolean.FALSE : Boolean.TRUE);
      }
      
      /**
       * <p>Convert an Integer to a Boolean using the convention that zero is false.</p>
       * 
       * <p>null will be converted to null.</p>
       * 
       * @param value  the Integer to convert
       * @return Boolean.TRUE if non-zero, Boolean.FALSE if zero, null if null
       */
      public static Boolean toBooleanObject(Integer value) {
          if (value == null) {
              return null;
          }
          return (value.intValue() == 0 ? Boolean.FALSE : Boolean.TRUE);
      }
      
      /**
       * <p>Convert an int to a boolean specifying the conversion values.</p>
       * 
       * @param value  the Integer to convert
       * @param trueValue  the value to match for true
       * @param falseValue  the value to match for false
       * @return true or false
       * @throws IllegalArgumentException if no match
       */
      public static boolean toBoolean(int value, int trueValue, int falseValue) {
          if (value == trueValue) {
              return true;
          } else if (value == falseValue) {
              return false;
          }
          // no match
          throw new IllegalArgumentException("The Integer did not match either specified value");
      }
      
      /**
       * <p>Convert an Integer to a boolean specifying the conversion values.</p>
       * 
       * @param value  the Integer to convert
       * @param trueValue  the value to match for true, may be null
       * @param falseValue  the value to match for false, may be null
       * @return true or false
       * @throws IllegalArgumentException if no match
       */
      public static boolean toBoolean(Integer value, Integer trueValue, Integer falseValue)
{
          if (value == null) {
              if (trueValue == null) {
                  return true;
              } else if (falseValue == null) {
                  return false;
              }
          } else if (value.equals(trueValue)) {
              return true;
          } else if (value.equals(falseValue)) {
              return false;
          }
          // no match
          throw new IllegalArgumentException("The Integer did not match either specified value");
      }
      
      /**
       * <p>Convert an int to a Boolean specifying the conversion values.</p>
       * 
       * @param value  the Integer to convert
       * @param trueValue  the value to match for true
       * @param falseValue  the value to match for false
       * @param nullValue  the value to to match for null
       * @return Boolean.TRUE, Boolean.FALSE, or null
       * @throws IllegalArgumentException if no match
       */
      public static Boolean toBooleanObject(int value, int trueValue, int falseValue, int
nullValue) {
          if (value == trueValue) {
              return Boolean.TRUE;
          } else if (value == falseValue) {
              return Boolean.FALSE;
          } else if (value == nullValue) {
              return null;
          }
          // no match
          throw new IllegalArgumentException("The Integer did not match any specified value");
      }
      
      /**
       * <p>Convert an Integer to a Boolean specifying the conversion values.</p>
       * 
       * @param value  the Integer to convert
       * @param trueValue  the value to match for true, may be null
       * @param falseValue  the value to match for false, may be null
       * @param nullValue  the value to to match for null, may be null
       * @return Boolean.TRUE, Boolean.FALSE, or null
       * @throws IllegalArgumentException if no match
       */
      public static Boolean toBooleanObject(Integer value, Integer trueValue, Integer falseValue,
Integer nullValue) {
          if (value == null) {
              if (trueValue == null) {
                  return Boolean.TRUE;
              } else if (falseValue == null) {
                  return Boolean.FALSE;
              } else if (nullValue == null) {
                  return null;
              }
          } else if (value.equals(trueValue)) {
              return Boolean.TRUE;
          } else if (value.equals(falseValue)) {
              return Boolean.FALSE;
          } else if (value.equals(nullValue)) {
              return null;
          }
          // no match
          throw new IllegalArgumentException("The Integer did not match any specified value");
      }
      
      // Boolean to Integer methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Convert a boolean to an int using the convention that zero is false.</p>
       * 
       * @param bool  the boolean to convert
       * @return one if true, zero if false
       */
      public static int toInteger(boolean bool) {
          return (bool ? 1 : 0);
      }
      
      /**
       * <p>Convert a boolean to an Integer using the convention that zero is false.</p>
       * 
       * @param bool  the boolean to convert
       * @return one if true, zero if false
       */
      public static Integer toIntegerObject(boolean bool) {
          return (bool ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO);
      }
      
      /**
       * <p>Convert a Boolean to a Integer using the convention that zero is false.</p>
       * 
       * <p>null will be converted to null.</p>
       * 
       * @param bool  the Boolean to convert
       * @return one if Boolean.TRUE, zero if Boolean.FALSE, null if null
       */
      public static Integer toIntegerObject(Boolean bool) {
          if (bool == null) {
              return null;
          }
          return (bool.booleanValue() ? NumberUtils.INTEGER_ONE : NumberUtils.INTEGER_ZERO);
      }
      
      /**
       * <p>Convert a boolean to an int specifying the conversion values.</p>
       * 
       * @param bool  the to convert
       * @param trueValue  the value to return if true
       * @param falseValue  the value to return if false
       * @param nullValue  the value to return if null
       * @return the appropriate value
       */
      public static int toInteger(boolean bool, int trueValue, int falseValue) {
          return (bool ? trueValue : falseValue);
      }
      
      /**
       * <p>Convert a Boolean to an int specifying the conversion values.</p>
       * 
       * @param bool  the Boolean to convert
       * @param trueValue  the value to return if true
       * @param falseValue  the value to return if false
       * @param nullValue  the value to return if null
       * @return the appropriate value
       */
      public static int toInteger(Boolean bool, int trueValue, int falseValue, int nullValue)
{
          if (bool == null) {
              return nullValue;
          }
          return (bool.booleanValue() ? trueValue : falseValue);
      }
      
      /**
       * <p>Convert a boolean to an Integer specifying the conversion values.</p>
       * 
       * @param bool  the to convert
       * @param trueValue  the value to return if true, may be null
       * @param falseValue  the value to return if false, may be null
       * @param nullValue  the value to return if null, may be null
       * @return the appropriate value
       */
      public static Integer toIntegerObject(boolean bool, Integer trueValue, Integer falseValue)
{
          return (bool ? trueValue : falseValue);
      }
      
      /**
       * <p>Convert a Boolean to an Integer specifying the conversion values.</p>
       * 
       * @param bool  the Boolean to convert
       * @param trueValue  the value to return if true, may be null
       * @param falseValue  the value to return if false, may be null
       * @param nullValue  the value to return if null, may be null
       * @return the appropriate value
       */
      public static Integer toIntegerObject(Boolean bool, Integer trueValue, Integer falseValue,
Integer nullValue) {
          if (bool == null) {
              return nullValue;
          }
          return (bool.booleanValue() ? trueValue : falseValue);
      }
      
      // String to Boolean methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Converts a String to a Boolean.</p>
       * 
       * <p>'true', 'on' or 'yes' (case insensitive) will return true.
       * 'false', 'off' or 'no' (case insensitive) will return false.
       * Otherwise, null is returned.</p>
       *
       * @param str  the String to check
       * @return the Boolean value of the string, null if no match or null input
       */
      public static Boolean toBooleanObject(String str) {
          if ("true".equalsIgnoreCase(str)) {
              return Boolean.TRUE;
          } else if ("false".equalsIgnoreCase(str)) {
              return Boolean.FALSE;
          } else if ("on".equalsIgnoreCase(str)) {
              return Boolean.TRUE;
          } else if ("off".equalsIgnoreCase(str)) {
              return Boolean.FALSE;
          } else if ("yes".equalsIgnoreCase(str)) {
              return Boolean.TRUE;
          } else if ("no".equalsIgnoreCase(str)) {
              return Boolean.FALSE;
          }
          // no match
          return null;
      }
  
      /**
       * <p>Converts a String to a Boolean throwing an exception if no match.</p>
       *
       * @param str  the String to check
       * @param trueString  the String to match for true (case sensitive), may be null
       * @param falseString  the String to match for false (case sensitive), may be null
       * @param nullString  the String to match for null (case sensitive), may be null
       * @return the Boolean value of the string, null if no match or null input
       */
      public static Boolean toBooleanObject(String str, String trueString, String falseString,
String nullString) {
          if (str == null) {
              if (trueString == null) {
                  return Boolean.TRUE;
              } else if (falseString == null) {
                  return Boolean.FALSE;
              } else if (nullString == null) {
                  return null;
              }
          } else if (str.equals(trueString)) {
              return Boolean.TRUE;
          } else if (str.equals(falseString)) {
              return Boolean.FALSE;
          } else if (str.equals(nullString)) {
              return null;
          }
          // no match
          throw new IllegalArgumentException("The String did not match any specified value");
      }
  
      // String to boolean methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Converts a String to a boolean.</p>
       * 
       * <p>'true', 'on' or 'yes' (case insensitive) will return true.
       * Otherwise, false is returned.</p>
       *
       * @param str  the String to check
       * @return the boolean value of the string, false if no match
       */
      public static boolean toBoolean(String str) {
          if ("true".equalsIgnoreCase(str)) {
              return true;
          } else if ("on".equalsIgnoreCase(str)) {
              return true;
          } else if ("yes".equalsIgnoreCase(str)) {
              return true;
          }
          // no match
          return false;
      }
  
      /**
       * <p>Converts a String to a Boolean throwing an exception if no match found.</p>
       * 
       * <p>null is returned if there is no match.</p>
       *
       * @param str  the String to check
       * @param trueString  the String to match for true (case sensitive), may be null
       * @param falseString  the String to match for false (case sensitive), may be null
       * @return the boolean value of the string
       * @throws IllegalArgumentException if the String doesn't match
       */
      public static boolean toBoolean(String str, String trueString, String falseString) {
          if (str == null) {
              if (trueString == null) {
                  return true;
              } else if (falseString == null) {
                  return false;
              }
          } else if (str.equals(trueString)) {
              return true;
          } else if (str.equals(falseString)) {
              return false;
          }
          // no match
          throw new IllegalArgumentException("The String did not match either specified value");
      }
  
      // Boolean to String methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Converts a Boolean to a String returning 'true', 'false', or <code>null</code>.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'true', 'false', or <code>null</code>
       */
      public static String toStringTrueFalse(Boolean bool) {
          return toString(bool, "true", "false", null);
      }
      
      /**
       * <p>Converts a Boolean to a String returning 'on', 'off', or <code>null</code>.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'on', 'off', or <code>null</code>
       */
      public static String toStringOnOff(Boolean bool) {
          return toString(bool, "on", "off", null);
      }
      
      /**
       * <p>Converts a Boolean to a String returning 'yes', 'no', or <code>null</code>.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'yes', 'no', or <code>null</code>
       */
      public static String toStringYesNo(Boolean bool) {
          return toString(bool, "yes", "no", null);
      }
      
      /**
       * <p>Converts a Boolean to a String returning one of the input Strings.</p>
       * 
       * @param bool  the Boolean to check
       * @param trueString  the String to return if true, may be null
       * @param falseString  the String to return if false, may be null
       * @param nullString  the String to return if null, may be null
       * @return one of the three input Strings
       */
      public static String toString(Boolean bool, String trueString, String falseString, String
nullString) {
          if (bool == null) {
              return nullString;
          }
          return (bool.booleanValue() ? trueString : falseString);
      }
      
      // boolean to String methods
      //--------------------------------------------------------------------------
      
      /**
       * <p>Converts a boolean to a String returning 'true' or 'false'.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'true', 'false', or <code>null</code>
       */
      public static String toStringTrueFalse(boolean bool) {
          return toString(bool, "true", "false");
      }
      
      /**
       * <p>Converts a boolean to a String returning 'on' or 'off'.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'on', 'off', or <code>null</code>
       */
      public static String toStringOnOff(boolean bool) {
          return toString(bool, "on", "off");
      }
      
      /**
       * <p>Converts a boolean to a String returning 'yes' or 'no'.</p>
       * 
       * @param bool  the Boolean to check
       * @return 'yes', 'no', or <code>null</code>
       */
      public static String toStringYesNo(boolean bool) {
          return toString(bool, "yes", "no");
      }
      
      /**
       * <p>Converts a boolean to a String returning one of the input Strings.</p>
       * 
       * @param bool  the Boolean to check
       * @param trueString  the String to return if true, may be null
       * @param falseString  the String to return if false, may be null
       * @return one of the two input Strings
       */
      public static String toString(boolean bool, String trueString, String falseString) {
          return (bool ? trueString : falseString);
      }
      
  }
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message