/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.beanutils.converters;

 import java.util.List;

 import org.apache.commons.beanutils.ConversionException;

 /**

  * <p>Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming

  * String into a primitive array of boolean.  On a conversion failure, returns

  * a specified default value or throws a {@link ConversionException} depending

  * on how this instance is constructed.</p>

  *

  * <p>By default, the values to be converted are expected to be those

  * recognised by a default instance of BooleanConverter. A customised

  * BooleanConverter can be provided in order to recognise alternative values

  * as true/false. </p>

  *

  * @author Craig R. McClanahan

  * @version $Revision: 690380 $ $Date: 2008-08-29 16:04:38 -0400 (Fri, 29 Aug 2008) $

  * @since 1.4

  * @deprecated Replaced by the new {@link ArrayConverter} implementation

  */

 public final class BooleanArrayConverter extends AbstractArrayConverter {

     // ----------------------------------------------------------- Constructors

     /**

      * Create a {@link org.apache.commons.beanutils.Converter} that will throw

      * a {@link ConversionException} if a conversion error occurs.

      *

      * <p>Conversion of strings to boolean values will be done via a default

      * instance of class BooleanConverter.</p>

      */

     public BooleanArrayConverter() {

         super();

         this.booleanConverter = DEFAULT_CONVERTER;

     }

     /**

      * Create a {@link org.apache.commons.beanutils.Converter} that will return

      * the specified default value if a conversion error occurs.

      *

      * <p>Conversion of strings to boolean values will be done via a default

      * instance of class BooleanConverter.</p>

      *

      * @param defaultValue The default value to be returned

      */

     public BooleanArrayConverter(Object defaultValue) {

         super(defaultValue);

         this.booleanConverter = DEFAULT_CONVERTER;

     }

     /**

      * Create a {@link org.apache.commons.beanutils.Converter} that will return

      * the specified default value if a conversion error occurs.

      *

      * <p>Conversion of strings to boolean values will be done via the

      * specified converter.</p>

      *

      * @param converter is the converter object that will be used to

      *  convert each input string-value into a boolean.

      *

      * @param defaultValue is the default value to be returned by method

      * convert if conversion fails; null is a valid default value. See the

      * documentation for method "convert" for more information.

      * The value BooleanArrayConverter.NO_DEFAULT may be passed here to

      * specify that an exception should be thrown on conversion failure.

      *  

      */

     public BooleanArrayConverter(BooleanConverter converter, Object defaultValue) {

         super(defaultValue);

         this.booleanConverter = converter;

     }

     // ------------------------------------------------------- Static Variables

     /**

      * Type which this class converts its input to. This value can be

      * used as a parameter to the ConvertUtils.register method.

      * @since 1.8.0

      */

     public static final Class MODEL = new boolean[0].getClass();

     /**

      * The converter that all instances of this class will use to

      * do individual string->boolean conversions, unless overridden

      * in the constructor.

      */

     private static final BooleanConverter DEFAULT_CONVERTER

         = new BooleanConverter();

     // ---------------------------------------------------- Instance Variables

     /**

      * This object is used to perform the conversion of individual strings

      * into Boolean/boolean values.

      */

     protected final BooleanConverter booleanConverter;

     // --------------------------------------------------------- Public Methods

     /**

      * Convert the specified input object into an output object of type

      * array-of-boolean.

      * 

      * <p>If the input value is null, then the default value specified in the

      * constructor is returned. If no such value was provided, then a

      * ConversionException is thrown instead.</p>

      *

      * <p>If the input value is of type String[] then the returned array shall

      * be of the same size as this array, with a true or false value in each

      * array element depending on the result of applying method

      * BooleanConverter.convert to each string.</p>

      *

      * <p>For all other types of value, the object's toString method is

      * expected to return a string containing a comma-separated list of

      * values, eg "true, false, true". See the documentation for

      * {@link AbstractArrayConverter#parseElements} for more information on

      * the exact formats supported.</p>

      *

      * <p>If the result of value.toString() cannot be split into separate

      * words, then the default value is also returned (or an exception thrown).

      * </p>

      *

      * <p>If any of the elements in the value array (or the elements resulting

      * from splitting up value.toString) are not recognised by the

      * BooleanConverter associated with this object, then what happens depends

      * on whether that BooleanConverter has a default value or not: if it does, 

      * then that unrecognised element is converted into the BooleanConverter's

      * default value. If the BooleanConverter does <i>not</i> have a default

      * value, then the default value for this object is returned as the

      * <i>complete</i> conversion result (not just for the element), or an 

      * exception is thrown if this object has no default value defined.</p>

      *

      * @param type is the type to which this value should be converted. In the

      *  case of this BooleanArrayConverter class, this value is ignored.

      *

      * @param value is the input value to be converted.

      *

      * @return an object of type boolean[], or the default value if there was

      *  any sort of error during conversion and the constructor

      *  was provided with a default value.

      *

      * @exception ConversionException if conversion cannot be performed

      *  successfully and the constructor was not provided with a default

      *  value to return on conversion failure.

      *

      * @exception NullPointerException if value is an array, and any of the

      * array elements are null.

      */

     public Object convert(Class type, Object value) {

         // Deal with a null value

         if (value == null) {

             if (useDefault) {

                 return (defaultValue);

             } else {

                 throw new ConversionException("No value specified");

             }

         }

         // Deal with the no-conversion-needed case

         if (MODEL == value.getClass()) {

             return (value);

         }

         // Deal with input value as a String array

         //

         // TODO: use if (value.getClass().isArray() instead...

         //  this requires casting to Object[], then using values[i].toString()

         if (strings.getClass() == value.getClass()) {

             try {

                 String[] values = (String[]) value;

                 boolean[] results = new boolean[values.length];

                 for (int i = 0; i < values.length; i++) {

                     String stringValue = values[i];

                     Object result = booleanConverter.convert(Boolean.class, stringValue);

                     results[i] = ((Boolean) result).booleanValue();

                 }

                 return (results);

             } catch (Exception e) {

                 if (useDefault) {

                     return (defaultValue);

                 } else {

                     throw new ConversionException(value.toString(), e);

                 }

             }

         }

         // We only get here if the input value is not of type String[].

         // In this case, we assume value.toString() returns a comma-separated

         // sequence of values; see method AbstractArrayConverter.parseElements

         // for more information.

         try {

             List list = parseElements(value.toString());

             boolean[] results = new boolean[list.size()];

             for (int i = 0; i < results.length; i++) {

                 String stringValue = (String) list.get(i);

                 Object result = booleanConverter.convert(Boolean.class, stringValue);

                 results[i] = ((Boolean) result).booleanValue();

             }

             return (results);

         } catch (Exception e) {

             if (useDefault) {

                 return (defaultValue);

             } else {

                 throw new ConversionException(value.toString(), e);

             }

         }

     }

 }