Java MappingIterator.readAll方法代碼示例

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
/**
 * Uses a {@link CsvMapper} to reading a String representing a CSV representation of a PDF
 * Chart, returning a list of {@link ChartCharacter}s
 */
static List<ChartCharacter> readChartCsv(String csvChart) throws ChartParserException {
    CsvSchema schema = CsvSchema.emptySchema()
            .withHeader()
            .withColumnSeparator('|')
            .withoutQuoteChar();

    try {
        MappingIterator<ChartCharacter> mappingIterator =
                getCsvMapper().readerFor(ChartCharacter.class)
                        .with(schema)
                        .readValues(csvChart);
        return mappingIterator.readAll();
    } catch (Exception e) {
        throw new ChartParserException("Error deserializing the Chart CSV data", e);
    }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
private Iterable<Map<String,String>> csvIteratorExistingHeaders(String filename, char escapeChar) throws JsonProcessingException, IOException {
	//InputStream in = new FileInputStream(filename, "UTF-8");
	InputStreamReader in = new InputStreamReader(new FileInputStream(filename), "ISO-8859-1");
       MappingIterator<Map<String, String>> iterator = new CsvMapper()
               .readerFor(Map.class)
               .with(CsvSchema.emptySchema().withColumnSeparator(',').withHeader().withEscapeChar(escapeChar))
               .readValues(in);
       List<Map<String,String>> sortable = iterator.readAll();
       if (sortable.get(0).containsKey("discussion_answer_created_ts")) {
       		sortable.sort(new Comparator<Map<String,String>>() {
       		    @Override
       		    public int compare(Map<String,String> lhs, Map<String,String> rhs) {
       		        return lhs.get("discussion_answer_created_ts").compareTo(rhs.get("discussion_answer_created_ts"));
       		    }
       		} );
       }
       return () -> sortable.iterator();
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
@Override
public List<PipelineState> getHistory(String pipelineName, String rev, boolean fromBeginning) throws PipelineStoreException {
  if (!pipelineDirExists(pipelineName, rev) || !pipelineStateHistoryFileExists(pipelineName, rev)) {
    return Collections.emptyList();
  }
  try (Reader reader = new FileReader(getPipelineStateHistoryFile(pipelineName, rev))){
    ObjectMapper objectMapper = ObjectMapperFactory.get();
    JsonParser jsonParser = objectMapper.getFactory().createParser(reader);
    MappingIterator<PipelineStateJson> pipelineStateMappingIterator =
      objectMapper.readValues(jsonParser, PipelineStateJson.class);
    List<PipelineStateJson> pipelineStateJsons = pipelineStateMappingIterator.readAll();
    Collections.reverse(pipelineStateJsons);
    if (fromBeginning) {
      return BeanHelper.unwrapPipelineStatesNewAPI(pipelineStateJsons);
    } else {
      int toIndex = pipelineStateJsons.size() > 100 ? 100 : pipelineStateJsons.size();
      return BeanHelper.unwrapPipelineStatesNewAPI(pipelineStateJsons.subList(0, toIndex));
    }
  } catch (IOException e) {
    throw new PipelineStoreException(ContainerError.CONTAINER_0115, pipelineName, rev, e.toString(), e);
  }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
/**
 * Parse the data from the given CSV file into a List of Maps, where the key is the
 * column name. Uses a LinkedHashMap specifically to ensure the order of columns is preserved in
 * the resulting maps.
 * 
 * @param csvData
 *          Raw CSV data
 * @return parsed data
 * @throws IOException
 *           if any exception occurs while parsing the data
 */
public static List<LinkedHashMap<String, String>> parse(String csvData) throws IOException {
  // Read schema from the first line; start with bootstrap instance
  // to enable reading of schema from the first line
  // NOTE: reads schema and uses it for binding
  CsvMapper mapper = new CsvMapper();
  // use first row as header; otherwise defaults are fine
  CsvSchema schema = CsvSchema.emptySchema().withHeader();

  MappingIterator<LinkedHashMap<String, String>> it = mapper.readerFor(LinkedHashMap.class)
      .with(schema).readValues(csvData);

  return it.readAll();
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
public List<Track> findAll() {
    CsvSchema schema = CsvSchema.emptySchema().withColumnSeparator(';').withHeader();

    try {
        try (InputStream tracks = getClass().getClassLoader().getResourceAsStream(FILENAME)) {
            MappingIterator<Track> mappingIterator = csvMapper.readerFor(Track.class)
                    .with(schema).readValues(tracks);
            return mappingIterator.readAll();
        }
    } catch (IOException e) {
        throw new RuntimeException(String.format("Unable to read %s as CSV", FILENAME),
                e);
    }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
/**
 * Map each line of the inventory report into a POJO
 * @return List<InventoryReportLine> which is a list of POJOs
 * @throws IOException when mapping with schema fails
 */
public List<InventoryReportLine> mapInventoryReportLine(List<String> inventoryReportLine) throws IOException{
    CsvMapper mapper = new CsvMapper();
    List<InventoryReportLine> inventoryReportLines = new ArrayList();

    for (String eachLine : inventoryReportLine) {
        MappingIterator<InventoryReportLine> iterator =
                mapper.readerFor(InventoryReportLine.class).with(schema).readValues(eachLine);
        List<InventoryReportLine> rowValue = iterator.readAll();
        inventoryReportLines.add(rowValue.get(0));
    }
    return inventoryReportLines;
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
private void workflowCreate() throws IOException, ExecutionException, InterruptedException {
  final String component = namespace.getString(parser.workflowCreateComponentId.getDest());
  final File file = namespace.get(parser.workflowCreateFile.getDest());

  final ObjectReader workflowReader = Json.YAML_MAPPER.reader()
      .forType(WorkflowConfiguration.class);
  final MappingIterator<WorkflowConfiguration> iterator;
  if (file == null || file.getName().equals("-")) {
    iterator = workflowReader.readValues(System.in);
  } else {
    iterator = workflowReader.readValues(file);
  }

  final List<WorkflowConfiguration> configurations = iterator.readAll();

  // TODO: validate workflows locally before creating them

  final List<CompletionStage<Workflow>> futures = configurations.stream()
      .map(configuration -> styxClient.createOrUpdateWorkflow(component, configuration))
      .collect(toList());

  for (CompletionStage<Workflow> future : futures) {
    final Workflow created = future.toCompletableFuture().get();
    cliOutput.printMessage("Workflow " + created.workflowId() + " in component "
        + created.componentId() + " created.");
  }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入方法依賴的package包/類
public List<String> convertToJsonRecords(InputStream payloadStream, int limit) throws Exception {
    MappingIterator<TruckEvent> csvTruckEvents = readTruckEventsFromCsv(payloadStream);
    List<String> jsons = new ArrayList<>();
    int ct = 0;
    for (TruckEvent truckEvent : csvTruckEvents.readAll()) {
        truckEvent.setMiles((long) new Random().nextInt(500));
        String json = new ObjectMapper().writeValueAsString(truckEvent);
        jsons.add(json);
        if (++ct == limit) {
            break;
        }
    }

    return jsons;
}