All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.supercsv.util.Util Maven / Gradle / Ivy

    Go to download

    Super CSV is a fast, programmer-friendly, free CSV package for Java

    There is a newer version: 2.4.0
    Show newest version
    /*
 * 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 null 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 null 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 destination, final List source,
		final CellProcessor[] processors, final int lineNo, final int rowNo) {
		
		if( destination == null ) {
			throw new NullPointerException("destination should not be null");
		} else if( source == null ) {
			throw new NullPointerException("source should not be null");
		} else if( processors == 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(source));
		
		if( source.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();
		
		for( int i = 0; i < source.size(); i++ ) {
			
			context.setColumnNumber(i + 1); // update context (columns start at 1)
			
			if( processors[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
	 * @throws NullPointerException
	 *             if destinationMap, nameMapping or sourceList are null
	 * @throws SuperCsvException
	 *             if nameMapping and sourceList are not the same size
	 */
	public static  void filterListToMap(final Map destinationMap, final String[] nameMapping,
		final List sourceList) {
		if( destinationMap == null ) {
			throw new NullPointerException("destinationMap should not be null");
		} else if( nameMapping == null ) {
			throw new NullPointerException("nameMapping should not be null");
		} else if( sourceList == null ) {
			throw new NullPointerException("sourceList should not be null");
		} else if( nameMapping.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();
		
		for( int i = 0; i < nameMapping.length; i++ ) {
			final String key = nameMapping[i];
			
			if( key == null ) {
				continue; // null's in the name mapping means skip column
			}
			
			// no duplicates allowed
			if( destinationMap.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 filterMapToList(final Map map, final String[] nameMapping) {
		if( map == null ) {
			throw new NullPointerException("map should not be null");
		} else if( nameMapping == null ) {
			throw new NullPointerException("nameMapping should not be null");
		}
		
		final List result = new ArrayList(nameMapping.length);
		for( final 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 values, final String[] nameMapping) {
		
		if( values == null ) {
			throw new NullPointerException("values should not be null");
		} else if( nameMapping == null ) {
			throw new NullPointerException("nameMapping should not be null");
		}
		
		final Object[] targetArray = new Object[nameMapping.length];
		int i = 0;
		for( final 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) {
		if( objectArray == null ) {
			return null;
		}
		
		final String[] stringArray = new String[objectArray.length];
		for( int i = 0; i < objectArray.length; i++ ) {
			stringArray[i] = objectArray[i] != null ? objectArray[i].toString() : null;
		}
		
		return stringArray;
	}
	
	/**
	 * Converts an List objectList) {
		if( objectList == null ) {
			return null;
		}
		
		final String[] stringArray = new String[objectList.size()];
		for( int i = 0; i < objectList.size(); i++ ) {
			stringArray[i] = objectList.get(i) != null ? objectList.get(i).toString() : null;
		}
		
		return stringArray;
	}
	
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy