Java CSVParser.DEFAULT_ESCAPE_CHARACTER属性代码示例

public List<InterpolatedDoublesCurve> parseCSVFile(URL fileUrl) {
  ArgumentChecker.notNull(fileUrl, "fileUrl");
  
  final List<InterpolatedDoublesCurve> curves = Lists.newArrayList();
  CSVDocumentReader csvDocumentReader = new CSVDocumentReader(fileUrl, CSVParser.DEFAULT_SEPARATOR, 
      CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER, new FudgeContext());
  
  List<FudgeMsg> rowsWithError = Lists.newArrayList();
  for (FudgeMsg row : csvDocumentReader) {
    try {
      curves.add( createCurve(row));
    } catch (Exception ex) {
      ex.printStackTrace();
      rowsWithError.add(row);
    }
  }
  
  s_logger.warn("Total unprocessed rows: {}", rowsWithError.size());
  for (FudgeMsg fudgeMsg : rowsWithError) {
    s_logger.warn("{}", fudgeMsg);
  }
  return curves;
}
 

public static Stream<Path> getRecentFiles() {
    try {
        String raw = PREFERENCES.get("recentFiles", "");
        /*
         * Use non-default constructor to set strictQuotes. This works
         * around a bug in the case that a single field is read with quotes
         * around it, eg "mypath". On decode the second quote is treated as
         * part of the string, so the result is the invalid `mypath"'
         */
        CSVParser parser = new CSVParser(
                CSVParser.DEFAULT_SEPARATOR,
                CSVParser.DEFAULT_QUOTE_CHARACTER,
                CSVParser.DEFAULT_ESCAPE_CHARACTER,
                true);

        return Stream.of(parser.parseLine(raw))
                .filter(string -> !string.isEmpty())
                .map(Paths::get)
                .filter(Files::exists);
    } catch (IOException ex) {
        LOG.log(Level.WARNING, null, ex);
        return Stream.empty();
    }
}
 

/**
 * Loads the exchange data
 * 
 * @param filename  the filename, not null
 */
private void loadExchangeData() {
  InputStream is = getClass().getResourceAsStream(EXCHANGE_ISO_FILE);
  if (is == null) {
    throw new OpenGammaRuntimeException("Unable to locate " + EXCHANGE_ISO_FILE);
  }
  CSVReader exchangeIsoReader = new CSVReader(new InputStreamReader(is), CSVParser.DEFAULT_SEPARATOR, CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER, 1);
  String [] nextLine;
  try {
    while ((nextLine = exchangeIsoReader.readNext()) != null) {
      String micCode = nextLine[0];
      String description = nextLine[1];
      String countryCode = nextLine[2];
      String country = nextLine[3];
      String city = nextLine[4];
      String acr = nextLine[5];
      String status = nextLine[7];
      if (StringUtils.isNotBlank(micCode) && StringUtils.isNotBlank(countryCode)) {
        Exchange exchange = new Exchange();
        exchange.setMic(micCode);
        exchange.setDescription(description);
        exchange.setCountryCode(countryCode);
        exchange.setCountry(country);
        exchange.setCity(city);
        exchange.setAcr(acr);
        exchange.setStatus(status);
        _exchangeMap.put(micCode, exchange);
        _exchangeDescriptionMap.put(description.toUpperCase(), exchange);
      }
    }
    exchangeIsoReader.close();
  } catch (IOException e) {
    throw new OpenGammaRuntimeException("Unable to read from " + EXCHANGE_ISO_FILE, e);
  }
}
 

CsvStreamReader(Source source) {
  this(source,
    CSVParser.DEFAULT_SEPARATOR,
    CSVParser.DEFAULT_QUOTE_CHARACTER,
    CSVParser.DEFAULT_ESCAPE_CHARACTER,
    DEFAULT_SKIP_LINES,
    CSVParser.DEFAULT_STRICT_QUOTES,
    CSVParser.DEFAULT_IGNORE_LEADING_WHITESPACE);
}
 

@Override
public FixTable create(TestRun testRun) throws Exception {
    try (CSVReader reader = new CSVReader(getFileReader(testRun), separator, CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER)) {
        List<String[]> myEntries = reader.readAll();
        String[] colNames = myEntries.get(0);
        List<String[]> rowData = myEntries.subList(1, myEntries.size());
        return StringArrayFixTableCreator.createFixTable(colNames, rowData);
    }
}
 

public CSVSettings() {
    this.separator = CSVParser.DEFAULT_SEPARATOR;
    this.quote = CSVParser.DEFAULT_QUOTE_CHARACTER;
    this.escape = CSVParser.DEFAULT_ESCAPE_CHARACTER;
    this.skipLines = 0;
    this.strictQuotes = CSVParser.DEFAULT_STRICT_QUOTES;
    this.ignoreLeadingWhiteSpace = CSVParser.DEFAULT_IGNORE_LEADING_WHITESPACE;
    this.charset = Charsets.UTF_8;
}
 

public TestFileIterator(String relationName, Reader reader, char separator, char quotechar,
                    int skipLines,
                    boolean hasHeader) throws InputIterationException {
  this(relationName, reader, separator, quotechar, CSVParser.DEFAULT_ESCAPE_CHARACTER, skipLines,
       CSVParser.DEFAULT_STRICT_QUOTES, CSVParser.DEFAULT_IGNORE_LEADING_WHITESPACE, hasHeader);
}
 

public List<IRSwapSecurity> parseCSVFile(URL tradeFileUrl) {
  ArgumentChecker.notNull(tradeFileUrl, "tradeFileUrl");
          
  List<IRSwapSecurity> trades = Lists.newArrayList();
  CSVDocumentReader csvDocumentReader = new CSVDocumentReader(tradeFileUrl, CSVParser.DEFAULT_SEPARATOR, 
      CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER, new FudgeContext());
  
  List<FudgeMsg> rowsWithError = Lists.newArrayList();
  List<FudgeMsg> unsupportedProdTypes = Lists.newArrayList();
  List<FudgeMsg> stubTrades = Lists.newArrayList();
  List<FudgeMsg> compoundTrades = Lists.newArrayList();
  List<FudgeMsg> missingPV = Lists.newArrayList();
  List<FudgeMsg> terminatedTrades = Lists.newArrayList();
  
  int count = 1;
  for (FudgeMsg row : csvDocumentReader) {
    count++;
    SwapSecurity swapSecurity = null;
    try {
      if (isUnsupportedProductType(row)) {
        unsupportedProdTypes.add(row);
        continue;
      }
      if (isStubTrade(row)) {
        stubTrades.add(row);
        continue;
      }
      if (isCompoundTrade(row)) {
        compoundTrades.add(row);
        continue;
      }
      if (isErsPVMissing(row)) {
        missingPV.add(row);
        continue;
      }
      if (isTeminatedTrade(row)) {
        terminatedTrades.add(row);
        continue;
      }
      swapSecurity = createSwapSecurity(row);
      trades.add(IRSwapSecurity.of(swapSecurity, row));
    } catch (Exception ex) {
      ex.printStackTrace();
      rowsWithError.add(row);
    }
  }
  
  logErrors("unsupportedProdTypes", unsupportedProdTypes, count);
  logErrors("stubTrades", stubTrades, count);
  logErrors("compoundTrades", compoundTrades, count);
  logErrors("missingPV", missingPV, count);
  logErrors("terminatedTrades", terminatedTrades, count);
      
  s_logger.warn("Total unprocessed rows: {} out of {}", rowsWithError.size(), count);
  for (FudgeMsg fudgeMsg : rowsWithError) {
    s_logger.warn("{}", fudgeMsg);
  }
  return trades;
}
 

public CSVInputReader(Reader fileReader, char separator) {
    final boolean ignoreLeadingWhitespace = false;
    reader = new CSVReader(fileReader, separator, CSVParser.DEFAULT_QUOTE_CHARACTER,
            CSVParser.DEFAULT_ESCAPE_CHARACTER, CSVReader.DEFAULT_SKIP_LINES, CSVParser.DEFAULT_STRICT_QUOTES, ignoreLeadingWhitespace);
}
 

/**
 * Constructs CSVDocumentReader using a comma for the separator.
 * 
 * @param docUrl the URL to the CSV source.
 */
public CSVDocumentReader(URL docUrl) {
  this(docUrl, CSVParser.DEFAULT_SEPARATOR, CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER, OpenGammaFudgeContext.getInstance());
}