/**
 * Constructs {@link CSVReader} with supplied {@link CSVParser}.
 *
 * @param aReader
 *        the reader to an underlying CSV source.
 * @param aParser
 *        the parser to use to parse input
 * @param bKeepCR
 *        <code>true</code> to keep carriage returns in data read,
 *        <code>false</code> otherwise
 */
public CSVReader (@Nonnull @WillCloseWhenClosed final Reader aReader,
                  @Nonnull final CSVParser aParser,
                  final boolean bKeepCR)
{
  ValueEnforcer.notNull (aReader, "Reader");
  ValueEnforcer.notNull (aParser, "Parser");

  Reader aInternallyBufferedReader = StreamHelper.getBuffered (aReader);
  if (bKeepCR)
    m_aLineReader = new CSVLineReaderKeepCR (aInternallyBufferedReader);
  else
  {
    if (!(aInternallyBufferedReader instanceof NonBlockingBufferedReader))
    {
      // It is buffered, but we need it to support readLine
      aInternallyBufferedReader = new NonBlockingBufferedReader (aInternallyBufferedReader);
    }
    m_aLineReader = new CSVLineReaderNonBlockingBufferedReader ((NonBlockingBufferedReader) aInternallyBufferedReader);
  }
  m_aReader = aInternallyBufferedReader;
  m_aParser = aParser;
  m_bKeepCR = bKeepCR;
}
 

@Nonnull
public static SafeXMLStreamWriter create (@Nonnull @WillCloseWhenClosed final OutputStream aOS,
                                          @Nonnull final IXMLWriterSettings aSettings)
{
  ValueEnforcer.notNull (aOS, "OutputStream");
  return create (new OutputStreamWriter (aOS, aSettings.getCharset ()), aSettings);
}
 

public MMapStringValueLookup(@WillCloseWhenClosed final BufferResource docIdToAddressBuffer,
                             @WillCloseWhenClosed final BufferResource stringValuesBuffer) {
    this.docIdToAddressBuffer = docIdToAddressBuffer;
    this.stringValuesBuffer = stringValuesBuffer;
    docIdToAddress = docIdToAddressBuffer.memory();
    stringValues = stringValuesBuffer.memory();
}
 

@MustBeClosed
public static BufferedReader reader(@WillCloseWhenClosed InputStream is) {
  return new BufferedReader(new InputStreamReader(is, UTF_8));
}
 

@MustBeClosed
static InputStream makeBuffered(@WillCloseWhenClosed InputStream is) {
  return (is instanceof BufferedInputStream || is instanceof ByteArrayInputStream)
      ? is
      : new BufferedInputStream(is);
}
 

@MustBeClosed
static OutputStream makeBuffered(@WillCloseWhenClosed OutputStream os) {
  return (os instanceof BufferedOutputStream || os instanceof ByteArrayOutputStream)
      ? os
      : new BufferedOutputStream(os);
}
 

public static Reader reader(@WillCloseWhenClosed InputStream in) {
    return new InputStreamReader(in, charset);
}
 

public static BufferedReader bufferedReader(@WillCloseWhenClosed InputStream in) {
    return new BufferedReader(reader(in));
}
 

public static Reader reader(@WillCloseWhenClosed InputStream in) {
    return new InputStreamReader(in, StandardCharsets.UTF_8);
}
 

public static BufferedReader bufferedReader(@WillCloseWhenClosed InputStream in) {
    return new BufferedReader(reader(in));
}
 

public OutputStreamXMLOutput(@WillCloseWhenClosed Writer writer, String stylesheet) {
    this.out = writer;
    this.nestingLevel = 0;
    this.newLine = true;
    this.stylesheet = stylesheet;
}
 

public void setBase(@WillCloseWhenClosed SourceRepository base) {
    this.base = base;
    ready.countDown();
}
 

public ZipSourceRepository(@WillCloseWhenClosed ZipFile zipFile) {
    this.zipFile = zipFile;
}
 

public static Reader getReader(@WillCloseWhenClosed InputStream in) {
    return UTF8.reader(in);
}
 

public static Writer getWriter(@WillCloseWhenClosed OutputStream out) {
    return UTF8.writer(out);
}
 

public ImprovedOutputStream(String name, @WillCloseWhenClosed OutputStream out) {
  this(name, out, true);
}
 

public ImprovedInputStream(String name, @WillCloseWhenClosed InputStream out) {
  this(name, out, true);
}
 

@Nonnull
public static SafeXMLStreamWriter create (@Nonnull @WillCloseWhenClosed final Writer aWriter,
                                          @Nonnull final IXMLWriterSettings aSettings)
{
  return new SafeXMLStreamWriter (new XMLEmitter (aWriter, aSettings));
}
 

InterruptibleInputStream(@WillCloseWhenClosed InputStream delegate) {
  this.delegate = delegate;
}
 

HashInputStream(@WillCloseWhenClosed InputStream delegate, Checksum checksum) {
  this.delegate = delegate;
  this.hasher = checksum.getKeyType().newHasher();
  this.code = checksum.getHashCode();
}
 

HttpStream(@WillCloseWhenClosed InputStream delegate, URL url) {
  super(delegate);
  this.url = url;
}
 

InputStream create(@WillCloseWhenClosed InputStream delegate, URL url, URL originalUrl) {
  return new ProgressInputStream(
      locale, clock, eventHandler, PROGRESS_INTERVAL_MS, delegate, url, originalUrl);
}
 

public HashOutputStream(@WillCloseWhenClosed OutputStream delegate, Checksum checksum) {
  this.delegate = delegate;
  this.hasher = checksum.getKeyType().newHasher();
  this.code = checksum.getHashCode();
}
 

/**
 * Constructor.
 *
 * @param os
 *            OutputStream to write XML output to
 * @param stylesheet
 *            name of stylesheet
 */
public OutputStreamXMLOutput(@WillCloseWhenClosed OutputStream os, String stylesheet) {
    this.out = new OutputStreamWriter(os, StandardCharsets.UTF_8);
    this.nestingLevel = 0;
    this.newLine = true;
    this.stylesheet = stylesheet;
}
 

/**
 * Constructs {@link CSVWriter} with all default settings.
 *
 * @param aWriter
 *        the writer to an underlying CSV source. May not be <code>null</code>
 *        .
 */
public CSVWriter (@Nonnull @WillCloseWhenClosed final Writer aWriter)
{
  ValueEnforcer.notNull (aWriter, "Writer");
  m_aRawWriter = aWriter;
  m_aPW = new PrintWriter (aWriter);
}
 

/**
 * Constructor.
 *
 * @param os
 *            OutputStream to write XML output to
 */
@SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION")
public OutputStreamXMLOutput(@WillCloseWhenClosed OutputStream os) {
    this(os, null);
}
 

/**
 * Constructor.
 *
 * @param writer
 *            Writer to write XML output to
 */
@SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION")
public OutputStreamXMLOutput(@WillCloseWhenClosed Writer writer) {
    this(writer, null);
}
 

/**
 * Constructs CSVReader using a comma for the separator.
 *
 * @param aReader
 *        the reader to an underlying CSV source.
 */
public CSVReader (@Nonnull @WillCloseWhenClosed final Reader aReader)
{
  this (aReader, new CSVParser (), CCSV.DEFAULT_KEEP_CR);
}
 

/**
 * Constructs {@link CSVReader} using a comma for the separator.
 *
 * @param aReader
 *        the reader to an underlying CSV source.
 * @param bKeepCR
 *        <code>true</code> to keep carriage returns in data read,
 *        <code>false</code> otherwise
 */
public CSVReader (@Nonnull @WillCloseWhenClosed final Reader aReader, final boolean bKeepCR)
{
  this (aReader, new CSVParser (), bKeepCR);
}