Open Source Repository

Home /supercsv/super-csv-2.3.1 | Repository Home



org/supercsv/util/Util.java
/*
 * Copyright 2007 Kasper B. Graversen
 
 * Licensed 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.supercsv.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.exception.SuperCsvConstraintViolationException;
import org.supercsv.exception.SuperCsvException;

/**
 * Useful utility methods.
 
 @author Kasper B. Graversen
 @author James Bassett
 */
public final class Util {
  
  // no instantiation
  private Util() {
  }
  
  /**
   * Processes each element in the source List (using the corresponding processor chain in the processors array) and
   * adds it to the destination List. A <tt>null</tt> CellProcessor in the array indicates that no processing is
   * required and the element should be added as-is.
   
   @param destination
   *            the List to add the processed elements to (which is cleared before it's populated)
   @param source
   *            the List of source elements to be processed
   @param processors
   *            the array of CellProcessors used to process each element. The number of elements in this array must
   *            match the size of the source List. A <tt>null</tt> CellProcessor in this array indicates that no
   *            processing is required and the element should be added as-is.
   @param lineNo
   *            the current line number
   @param rowNo
   *            the current row number
   @throws NullPointerException
   *             if destination, source or processors is null
   @throws SuperCsvConstraintViolationException
   *             if a CellProcessor constraint failed
   @throws SuperCsvException
   *             if source.size() != processors.length, or CellProcessor execution failed
   */
  public static void executeCellProcessors(final List<Object> destination, final List<?> source,
    final CellProcessor[] processors, final int lineNo, final int rowNo) {
    
    ifdestination == null ) {
      throw new NullPointerException("destination should not be null");
    else ifsource == null ) {
      throw new NullPointerException("source should not be null");
    else ifprocessors == null ) {
      throw new NullPointerException("processors should not be null");
    }
    
    // the context used when cell processors report exceptions
    final CsvContext context = new CsvContext(lineNo, rowNo, 1);
    context.setRowSource(new ArrayList<Object>(source));
    
    ifsource.size() != processors.length ) {
      throw new SuperCsvException(String.format(
        "The number of columns to be processed (%d) must match the number of CellProcessors (%d): check that the number"
          " of CellProcessors you have defined matches the expected number of columns being read/written",
        source.size(), processors.length), context);
    }
    
    destination.clear();
    
    forint i = 0; i < source.size(); i++ ) {
      
      context.setColumnNumber(i + 1)// update context (columns start at 1)
      
      ifprocessors[i== null ) {
        destination.add(source.get(i))// no processing required
      else {
        destination.add(processors[i].execute(source.get(i), context))// execute the processor chain
      }
    }
  }
  
  /**
   * Converts a List to a Map using the elements of the nameMapping array as the keys of the Map.
   
   @param destinationMap
   *            the destination Map (which is cleared before it's populated)
   @param nameMapping
   *            the keys of the Map (corresponding with the elements in the sourceList). Cannot contain duplicates.
   @param sourceList
   *            the List to convert
   @param <T>
   *            the type of the values in the map
   @throws NullPointerException
   *             if destinationMap, nameMapping or sourceList are null
   @throws SuperCsvException
   *             if nameMapping and sourceList are not the same size
   */
  public static <T> void filterListToMap(final Map<String, T> destinationMap, final String[] nameMapping,
    final List<? extends T> sourceList) {
    ifdestinationMap == null ) {
      throw new NullPointerException("destinationMap should not be null");
    else ifnameMapping == null ) {
      throw new NullPointerException("nameMapping should not be null");
    else ifsourceList == null ) {
      throw new NullPointerException("sourceList should not be null");
    else ifnameMapping.length != sourceList.size() ) {
      throw new SuperCsvException(
        String
          .format(
            "the nameMapping array and the sourceList should be the same size (nameMapping length = %d, sourceList size = %d)",
            nameMapping.length, sourceList.size()));
    }
    
    destinationMap.clear();
    
    forint i = 0; i < nameMapping.length; i++ ) {
      final String key = nameMapping[i];
      
      ifkey == null ) {
        continue// null's in the name mapping means skip column
      }
      
      // no duplicates allowed
      ifdestinationMap.containsKey(key) ) {
        throw new SuperCsvException(String.format("duplicate nameMapping '%s' at index %d", key, i));
      }
      
      destinationMap.put(key, sourceList.get(i));
    }
  }
  
  /**
   * Returns a List of all of the values in the Map whose key matches an entry in the nameMapping array.
   
   @param map
   *            the map
   @param nameMapping
   *            the keys of the Map values to add to the List
   @return a List of all of the values in the Map whose key matches an entry in the nameMapping array
   @throws NullPointerException
   *             if map or nameMapping is null
   */
  public static List<Object> filterMapToList(final Map<String, ?> map, final String[] nameMapping) {
    ifmap == null ) {
      throw new NullPointerException("map should not be null");
    else ifnameMapping == null ) {
      throw new NullPointerException("nameMapping should not be null");
    }
    
    final List<Object> result = new ArrayList<Object>(nameMapping.length);
    forfinal String key : nameMapping ) {
      result.add(map.get(key));
    }
    return result;
  }
  
  /**
   * Converts a Map to an array of objects, adding only those entries whose key is in the nameMapping array.
   
   @param values
   *            the Map of values to convert
   @param nameMapping
   *            the keys to extract from the Map (elements in the target array will be added in this order)
   @return the array of Objects
   @throws NullPointerException
   *             if values or nameMapping is null
   */
  public static Object[] filterMapToObjectArray(final Map<String, ?> values, final String[] nameMapping) {
    
    ifvalues == null ) {
      throw new NullPointerException("values should not be null");
    else ifnameMapping == null ) {
      throw new NullPointerException("nameMapping should not be null");
    }
    
    final Object[] targetArray = new Object[nameMapping.length];
    int i = 0;
    forfinal String name : nameMapping ) {
      targetArray[i++= values.get(name);
    }
    return targetArray;
  }
  
  /**
   * Converts an Object array to a String array (null-safe), by calling toString() on each element.
   
   @param objectArray
   *            the Object array
   @return the String array, or null if objectArray is null
   */
  public static String[] objectArrayToStringArray(final Object[] objectArray) {
    ifobjectArray == null ) {
      return null;
    }
    
    final String[] stringArray = new String[objectArray.length];
    forint i = 0; i < objectArray.length; i++ ) {
      stringArray[i= objectArray[i!= null ? objectArray[i].toString() null;
    }
    
    return stringArray;
  }
  
  /**
   * Converts an {@code List<Object>} to a String array (null-safe), by calling {@code toString()} on each element.
   
   @param objectList
   *            the List
   @return the String array, or null if objectList is null
   */
  public static String[] objectListToStringArray(final List<?> objectList) {
    ifobjectList == null ) {
      return null;
    }
    
    final String[] stringArray = new String[objectList.size()];
    forint i = 0; i < objectList.size(); i++ ) {
      stringArray[i= objectList.get(i!= null ? objectList.get(i).toString() null;
    }
    
    return stringArray;
  }
  
}