How to use

CsvMapReader

in

org.supercsv.io

private static CsvPOJO readWithCsvMapReader(String file) throws Exception {
  CsvPOJO csvPojo = new CsvPOJO();
  Map<String, String> readMap = null;
  ICsvMapReader mapReader = null;
  try {
    mapReader = new CsvMapReader(new FileReader(file), CsvPreference.STANDARD_PREFERENCE);
    String[] headers = mapReader.getHeader(true);
    List<CsvRow> rows = new ArrayList<CsvRow>();
    while ((readMap = mapReader.read(headers)) != null) {
      CsvRow row = new CsvRow();
      List<String> columns = new ArrayList<String>();
      for (String h : headers) {
        if (!StrUtil.isEmpty(h)) {
          columns.add(readMap.get(h));
        }
      }
      row.setCols(columns);
      rows.add(row);
    }
    csvPojo.setHeaders(headers);
    csvPojo.setRows(rows);
  } finally {
    if (mapReader != null) {
      mapReader.close();
    }
  }
  return csvPojo;
}

static
public TableEvaluationRequest readTable(BufferedReader reader, CsvPreference format) throws IOException {
  CsvMapReader parser = new CsvMapReader(reader, format);
  String[] header = parser.getHeader(true);
  List<String> columns = Arrays.asList(header);
  TableEvaluationRequest tableRequest = new TableEvaluationRequest()
    .setColumns(columns);
  String idColumn = tableRequest.getIdColumn();
  List<EvaluationRequest> requests = new ArrayList<>();
  while(true){
    Map<String, String> row = parser.read(header);
    if(row == null){
      break;
    }
    String id = null;
    if(idColumn != null){
      id = row.remove(idColumn);
    }
    EvaluationRequest request = new EvaluationRequest(id)
      .setArguments(row);
    requests.add(request);
  }
  tableRequest.setRequests(requests);
  parser.close();
  return tableRequest;
}

/**
 * TODO: keep track of duplicate or missing keys with special status codes
 * @param shapeFile
 * @return
 * @throws IOException
 */
private Map<String, MappingInfo> readExisting(WikiBrainShapeFile shapeFile) throws IOException {
  HashMap<String, MappingInfo> mapping = new HashMap<String, MappingInfo>();
  if (!shapeFile.hasMappingFile()) {
    return mapping;
  }
  CsvMapReader reader = new CsvMapReader(
      WpIOUtils.openBufferedReader(shapeFile.getMappingFile()),
      CsvPreference.STANDARD_PREFERENCE
  );
  String [] header = reader.getHeader(true);
  while (true) {
    Map<String, String> row = reader.read(header);
    if (row == null) {
      break;
    }
    MappingInfo info = new MappingInfo(row);
    if (!info.isUnknown()) {
      mapping.put(info.key, info);
    }
  }
  return mapping;
}

int linenum = 0;
String[] columns = in.getHeader(true);
Map<String, String> testRow = null;
while ((testRow = in.read(columns)) != null) {

/**
 * Extracts the fields from a delimited record and returns a map containing
 * field names and values
 */
@Override
Map<String, Object> extractFields(String line)
{
 if (!initialized) {
  init();
  initialized = true;
 }
 if (StringUtils.isBlank(line) || StringUtils.equals(line, header)) {
  return null;
 }
 try {
  csvStringReader.open(line);
  return csvMapReader.read(nameMapping, processors);
 } catch (IOException e) {
  logger.error("Error parsing line{} Exception {}", line, e.getMessage());
  return null;
 }
}

@Override
public void teardown()
{
 try {
  csvMapReader.close();
 } catch (IOException e) {
  logger.error("Error while closing csv map reader {}", e.getMessage());
  DTThrowable.wrapIfChecked(e);
 }
 try {
  csvBeanReader.close();
 } catch (IOException e) {
  logger.error("Error while closing csv bean reader {}", e.getMessage());
  DTThrowable.wrapIfChecked(e);
 }
}

/**
 * TODO: keep track of duplicate or missing keys with special status codes
 * @param shapeFile
 * @return
 * @throws IOException
 */
private Map<String, MappingInfo> readExisting(WikiBrainShapeFile shapeFile) throws IOException {
  HashMap<String, MappingInfo> mapping = new HashMap<String, MappingInfo>();
  if (!shapeFile.hasMappingFile()) {
    return mapping;
  }
  CsvMapReader reader = new CsvMapReader(
      WpIOUtils.openBufferedReader(shapeFile.getMappingFile()),
      CsvPreference.STANDARD_PREFERENCE
  );
  String [] header = reader.getHeader(true);
  while (true) {
    Map<String, String> row = reader.read(header);
    if (row == null) {
      break;
    }
    MappingInfo info = new MappingInfo(row);
    if (!info.isUnknown()) {
      mapping.put(info.key, info);
    }
  }
  return mapping;
}

/**
 * Extracts the fields from a delimited record and returns a map containing
 * field names and values
 */
@Override
Map<String, Object> extractFields(String line)
{
 if (!initialized) {
  init();
  initialized = true;
 }
 if (StringUtils.isBlank(line) || StringUtils.equals(line, header)) {
  return null;
 }
 try {
  csvStringReader.open(line);
  return csvMapReader.read(nameMapping, processors);
 } catch (IOException e) {
  logger.error("Error parsing line{} Exception {}", line, e.getMessage());
  return null;
 }
}

@Override
public void teardown()
{
 try {
  csvMapReader.close();
 } catch (IOException e) {
  logger.error("Error while closing csv map reader {}", e.getMessage());
  DTThrowable.wrapIfChecked(e);
 }
 try {
  csvBeanReader.close();
 } catch (IOException e) {
  logger.error("Error while closing csv bean reader {}", e.getMessage());
  DTThrowable.wrapIfChecked(e);
 }
}

/**
 * Create a typical CSV writer -- Excel compliant
 *
 * @param file
 * @return
 * @throws IOException
 */
public CsvMapReader open(String file) throws IOException {
  InputStreamReader rdr = FileUtility.getInputStream(file, "UTF-8");
  CsvMapReader R = new CsvMapReader(rdr, CsvPreference.STANDARD_PREFERENCE);
  return R;
}

  throw new IOException("No mapping file found: " + getMappingFile());
CsvMapReader reader = new CsvMapReader(
    WpIOUtils.openBufferedReader(getMappingFile()),
    CsvPreference.STANDARD_PREFERENCE
String [] header = reader.getHeader(true);
while (true) {
  Map<String, String> row = reader.read(header);
  if (row == null) {
    break;

if (parsedOutput.isConnected()) {
 csvStringReader.open(incomingString);
 Map<String, Object> map = csvMapReader.read(nameMapping, processors);
 parsedOutput.emit(map);
 parsedOutputCount++;

/**
 * This method creates an instance of csvMapReader.
 *
 * @param reader
 * @param preference
 * @return CSV Map Reader
 */
@Override
protected ICsvMapReader getReader(ReusableStringReader reader, CsvPreference preference)
{
 csvReader = new CsvMapReader(reader, preference);
 return csvReader;
}

  throw new IOException("No mapping file found: " + getMappingFile());
CsvMapReader reader = new CsvMapReader(
    WpIOUtils.openBufferedReader(getMappingFile()),
    CsvPreference.STANDARD_PREFERENCE
String [] header = reader.getHeader(true);
while (true) {
  Map<String, String> row = reader.read(header);
  if (row == null) {
    break;

if (parsedOutput.isConnected()) {
 csvStringReader.open(incomingString);
 Map<String, Object> map = csvMapReader.read(nameMapping, processors);
 parsedOutput.emit(map);
 parsedOutputCount++;

protected List<Map<String, Object>> readCsvFile(URI fileUrl) {
 List<Map<String, Object>> result = Lists.newArrayList();
 ICsvMapReader mapReader = null;
 try {
  mapReader = new CsvMapReader(new FileReader(new File(fileUrl)), CsvPreference.STANDARD_PREFERENCE);
  // the header columns are used as the keys to the Map
  String[] headers = getHeaders();
  CellProcessor[] processors = getProcessors();
  Map<String, Object> contentsMap;
  while( (contentsMap = mapReader.read(headers, processors)) != null ) {
   result.add(contentsMap);
  }
 } catch (Exception e) {
  LOGGER.error("Fail to read result file : {}", e.getMessage());
  throw new RuntimeException("Fail to read result file.");
 } finally {
  if( mapReader != null ) {
   try {
    mapReader.close();
   } catch (IOException e) {}
  }
 }
 LOGGER.info("Query Result Count : " + result.size());
 return result;
}

public static Map<String, String> readWithCsvMapReader(Path dicoFile) throws Exception {
  try (ICsvMapReader mapReader = new CsvMapReader(Files.newBufferedReader(dicoFile, StandardCharsets.UTF_8), CsvPreference.EXCEL_NORTH_EUROPE_PREFERENCE)) {
    final String[] header = mapReader.getHeader(true);
    LOGGER.debug(" cvsheader length: " + header.length);

private Map<String, String> readWithCsvMapReader(Path mappingFile) throws IOException {
  Map<String, String> retMap = new HashMap<>();
  try (ICsvMapReader mapReader = new CsvMapReader(Files.newBufferedReader(mappingFile, StandardCharsets.UTF_8), CsvPreference.STANDARD_PREFERENCE)) {
    final String[] header = mapReader.getHeader(true);
    log.info(" cvsheader length: " + header.length);

private static void parseCsv(InputStream is, Set<HistoDbAttributeId> ids, Table<Integer, String, Float> hdTable, int expectedRowCount) throws IOException {
  int rowcount = 0;
  try (ICsvMapReader mapReader = new CsvMapReader(new InputStreamReader(is), new CsvPreference.Builder('"', ',', "\r\n").build())) {

private JsonNode readCsvFile(URI fileUrl) {
 ArrayNode resultNode = GlobalObjectMapper.getDefaultMapper().createArrayNode();
 ICsvMapReader mapReader = null;
 try {
  mapReader = new CsvMapReader(new FileReader(new File(fileUrl)), CsvPreference.STANDARD_PREFERENCE);
  // the header columns are used as the keys to the Map
  String[] headers = getHeaders();
  CellProcessor[] processors = getProcessors();
  Map<String, Object> contentsMap;
  while( (contentsMap = mapReader.read(headers, processors)) != null ) {
   LOGGER.debug(String.format("lineNo=%s, rowNo=%s, customerMap=%s", mapReader.getLineNumber(),
       mapReader.getRowNumber(), contentsMap));
   resultNode.add(GlobalObjectMapper.getDefaultMapper().convertValue(contentsMap, JsonNode.class));
  }
 } catch (Exception e) {
  LOGGER.error("Fail to read result file : {}", e.getMessage());
  throw new RuntimeException("Fail to read result file.");
 } finally {
  if( mapReader != null ) {
   try {
    mapReader.close();
   } catch (IOException e) {}
  }
 }
 return resultNode;
}