import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
@Test
public void testCompressionStandalone () throws IOException
{
  final byte [] aSrc = StreamHelper.getAllBytes (ClassPathResource.getInputStream ("SOAPBodyPayload.xml"));
  assertNotNull (aSrc);

  // Compression
  final NonBlockingByteArrayOutputStream aCompressedOS = new NonBlockingByteArrayOutputStream ();
  _compressPayload (new NonBlockingByteArrayInputStream (aSrc), aCompressedOS);
  final byte [] aCompressed = aCompressedOS.toByteArray ();

  // DECOMPRESSION
  final NonBlockingByteArrayOutputStream aDecompressedOS = new NonBlockingByteArrayOutputStream ();
  _decompressPayload (new NonBlockingByteArrayInputStream (aCompressed), aDecompressedOS);
  final byte [] aDecompressed = aDecompressedOS.toByteArray ();

  assertArrayEquals (aSrc, aDecompressed);
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
private STXCharStream (@Nonnull final Reader aReader,
                       @Nonnegative final int nStartLine,
                       @Nonnegative final int nStartColumn,
                       @Nonnegative final int nBufferSize)
{
  ValueEnforcer.isGE0 (nBufferSize, "BufferSize");
  // Using a buffered reader gives a minimal speedup
  m_aReader = StreamHelper.getBuffered (ValueEnforcer.notNull (aReader, "Reader"));
  m_nLine = ValueEnforcer.isGE0 (nStartLine, "StartLine");
  m_nColumn = ValueEnforcer.isGE0 (nStartColumn, "StartColumn") - 1;

  m_nAvailable = nBufferSize;
  m_nBufsize = nBufferSize;
  m_aBuffer = new char [nBufferSize];
  m_aBufLine = new int [nBufferSize];
  m_aBufColumn = new int [nBufferSize];
  m_aNextCharBuf = new char [DEFAULT_BUF_SIZE];
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
public void close () throws IOException
{
  // Avoid double closing
  if (!m_aClosing.getAndSet (true))
  {
    m_aLock.lock ();
    try
    {
      // Start closing
      StreamHelper.close (m_aIndexReader);

      // Ensure to commit the writer in case of pending changes
      if (m_aIndexWriter != null && m_aIndexWriter.isOpen ())
        m_aIndexWriter.commit ();
      StreamHelper.close (m_aIndexWriter);
      StreamHelper.close (m_aDir);
      s_aLogger.info ("Closed Lucene reader/writer/directory");
    }
    finally
    {
      m_aLock.unlock ();
    }
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Write the passed object to an {@link OutputStream}.
 *
 * @param aObject
 *        The object to be written. May not be <code>null</code>.
 * @param aOS
 *        The output stream to write to. Will always be closed. May not be
 *        <code>null</code>.
 * @return {@link ESuccess}
 */
@Nonnull
default ESuccess write (@Nonnull final JAXBTYPE aObject, @Nonnull @WillClose final OutputStream aOS)
{
  try
  {
    if (USE_JAXB_CHARSET_FIX)
    {
      return write (aObject, SafeXMLStreamWriter.create (aOS, getXMLWriterSettings ()));
    }
    return write (aObject, TransformResultFactory.create (aOS));
  }
  finally
  {
    // Needs to be manually closed
    StreamHelper.close (aOS);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Read a document from the specified input stream. The secure reading feature
 * has affect when using this method.
 *
 * @param aIS
 *        The input stream to read. May not be <code>null</code>.
 * @return <code>null</code> in case reading fails.
 */
@Nullable
default JAXBTYPE read (@Nonnull final InputStream aIS)
{
  ValueEnforcer.notNull (aIS, "InputStream");

  final InputStreamAndCharset aISAndBOM = CharsetHelper.getInputStreamAndCharsetFromBOM (aIS);
  if (aISAndBOM.hasCharset ())
  {
    // BOM was found - read from Reader
    return read (StreamHelper.createReader (aISAndBOM.getInputStream (), aISAndBOM.getCharset ()));
  }

  // No BOM found - use the returned InputStream anyway, so that the pushed
  // back bytes are read
  return read (InputSourceFactory.create (aISAndBOM.getInputStream ()));
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Invoked the external process "neato" from the GraphViz package. Attention:
 * this spans a sub-process!
 *
 * @param sFileType
 *        The file type to be generated. E.g. "png" - see neato help for
 *        details. May neither be <code>null</code> nor empty.
 * @param sDOT
 *        The DOT file to be converted to an image. May neither be
 *        <code>null</code> nor empty.
 * @return The byte buffer that keeps the converted image. Never
 *         <code>null</code>.
 * @throws IOException
 *         In case some IO error occurs
 * @throws InterruptedException
 *         If the sub-process did not terminate correctly!
 */
@Nonnull
public static NonBlockingByteArrayOutputStream getGraphAsImageWithGraphVizNeato (@Nonnull @Nonempty final String sFileType,
                                                                                 @Nonnull final String sDOT) throws IOException,
                                                                                                             InterruptedException
{
  ValueEnforcer.notEmpty (sFileType, "FileType");
  ValueEnforcer.notEmpty (sDOT, "DOT");

  final ProcessBuilder aPB = new ProcessBuilder ("neato", "-T" + sFileType).redirectErrorStream (false);
  final Process p = aPB.start ();
  // Set neato stdin
  p.getOutputStream ().write (sDOT.getBytes (StandardCharsets.UTF_8));
  p.getOutputStream ().close ();
  // Read neato stdout
  final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream ();
  StreamHelper.copyInputStreamToOutputStream (p.getInputStream (), aBAOS);
  p.waitFor ();
  return aBAOS;
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
@Nullable
public static IMicroDocument readMicroXML (@WillClose @Nullable final InputStream aIS,
                                           @Nullable final ISAXReaderSettings aSettings)
{
  if (aIS == null)
    return null;

  try
  {
    return readMicroXML (InputSourceFactory.create (aIS), aSettings);
  }
  finally
  {
    StreamHelper.close (aIS);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Write a Micro Node to a {@link Writer}.
 *
 * @param aNode
 *        The node to be serialized. May be any kind of node (incl.
 *        documents). May not be <code>null</code>.
 * @param aWriter
 *        The writer to write to. May not be <code>null</code>. The writer is
 *        closed anyway directly after the operation finishes (on success and
 *        on error).
 * @param aSettings
 *        The settings to be used for the creation. May not be
 *        <code>null</code>.
 * @return {@link ESuccess}
 */
@Nonnull
public static ESuccess writeToWriter (@Nonnull final IMicroNode aNode,
                                      @Nonnull @WillClose final Writer aWriter,
                                      @Nonnull final IXMLWriterSettings aSettings)
{
  ValueEnforcer.notNull (aNode, "Node");
  ValueEnforcer.notNull (aWriter, "Writer");
  ValueEnforcer.notNull (aSettings, "Settings");

  try
  {
    final MicroSerializer aSerializer = new MicroSerializer (aSettings);
    aSerializer.write (aNode, aWriter);
    return ESuccess.SUCCESS;
  }
  finally
  {
    StreamHelper.close (aWriter);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Write the passed map to the passed output stream using the predefined XML
 * layout.
 *
 * @param aMap
 *        The map to be written. May not be <code>null</code>.
 * @param aOS
 *        The output stream to write to. The stream is closed independent of
 *        success or failure. May not be <code>null</code>.
 * @return {@link ESuccess#SUCCESS} when everything went well,
 *         {@link ESuccess#FAILURE} otherwise.
 */
@Nonnull
public static ESuccess writeMap (@Nonnull final Map <String, String> aMap, @Nonnull @WillClose final OutputStream aOS)
{
  ValueEnforcer.notNull (aMap, "Map");
  ValueEnforcer.notNull (aOS, "OutputStream");

  try
  {
    final IMicroDocument aDoc = createMapDocument (aMap);
    return MicroWriter.writeToStream (aDoc, aOS, XMLWriterSettings.DEFAULT_XML_SETTINGS);
  }
  finally
  {
    StreamHelper.close (aOS);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Write the passed collection to the passed output stream using the
 * predefined XML layout.
 *
 * @param aCollection
 *        The map to be written. May not be <code>null</code>.
 * @param aOS
 *        The output stream to write to. The stream is closed independent of
 *        success or failure. May not be <code>null</code>.
 * @return {@link ESuccess#SUCCESS} when everything went well,
 *         {@link ESuccess#FAILURE} otherwise.
 */
@Nonnull
public static ESuccess writeList (@Nonnull final Collection <String> aCollection,
                                  @Nonnull @WillClose final OutputStream aOS)
{
  ValueEnforcer.notNull (aCollection, "Collection");
  ValueEnforcer.notNull (aOS, "OutputStream");

  try
  {
    final IMicroDocument aDoc = createListDocument (aCollection);
    return MicroWriter.writeToStream (aDoc, aOS, XMLWriterSettings.DEFAULT_XML_SETTINGS);
  }
  finally
  {
    StreamHelper.close (aOS);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Read the Json from the passed {@link InputStream}.
 *
 * @param aIS
 *        The input stream to use. May not be <code>null</code>.
 * @param aFallbackCharset
 *        The charset to be used in case no BOM is present. May not be
 *        <code>null</code>.
 * @param aCustomExceptionCallback
 *        An optional custom exception handler that can be used to collect the
 *        unrecoverable parsing errors. May be <code>null</code>.
 * @return <code>null</code> if reading failed, the Json declarations
 *         otherwise.
 */
@Nullable
public static IJson readFromStream (@Nonnull final InputStream aIS,
                                    @Nonnull final Charset aFallbackCharset,
                                    @Nullable final IJsonParseExceptionCallback aCustomExceptionCallback)
{
  ValueEnforcer.notNull (aIS, "InputStream");
  ValueEnforcer.notNull (aFallbackCharset, "FallbackCharset");

  try
  {
    final Reader aReader = CharsetHelper.getReaderByBOM (aIS, aFallbackCharset);
    return _readJson (aReader, aCustomExceptionCallback);
  }
  finally
  {
    StreamHelper.close (aIS);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
private CSSCharStream (@Nonnull final Reader aReader,
                       @Nonnegative final int nStartLine,
                       @Nonnegative final int nStartColumn,
                       @Nonnegative final int nBufferSize)
{
  ValueEnforcer.isGE0 (nBufferSize, "BufferSize");
  // Using a buffered reader gives a minimal speedup
  m_aReader = StreamHelper.getBuffered (ValueEnforcer.notNull (aReader, "Reader"));
  m_nLine = ValueEnforcer.isGE0 (nStartLine, "StartLine");
  m_nColumn = ValueEnforcer.isGE0 (nStartColumn, "StartColumn") - 1;

  m_nAvailable = nBufferSize;
  m_nBufsize = nBufferSize;
  m_aBuffer = new char [nBufferSize];
  m_aBufLine = new int [nBufferSize];
  m_aBufColumn = new int [nBufferSize];
  m_aNextCharBuf = new char [DEFAULT_BUF_SIZE];
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
@Nonnull
private static ByteBuffer _convert (@Nonnull @WillClose final ReadableByteChannel aChannel) throws IOException
{
  try
  {
    final ByteBuffer buf = ByteBuffer.allocate (1024);
    final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream ();
    final WritableByteChannel aOutChannel = Channels.newChannel (aBAOS);
    while (aChannel.read (buf) > 0)
    {
      buf.flip ();
      aOutChannel.write (buf);
    }
    return ByteBuffer.wrap (aBAOS.toByteArray ());
  }
  finally
  {
    StreamHelper.close (aChannel);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
@Nullable
public static NonBlockingProperties loadProperties (@Nonnull @WillClose final Reader aReader)
{
  ValueEnforcer.notNull (aReader, "Reader");

  final Reader aBufferedReader = StreamHelper.getBuffered (aReader);
  try
  {
    final NonBlockingProperties aProps = new NonBlockingProperties ();
    aProps.load (aBufferedReader);
    return aProps;
  }
  catch (final IOException ex)
  {
    return null;
  }
  finally
  {
    StreamHelper.close (aBufferedReader);
    StreamHelper.close (aReader);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
public void decode (@Nullable final byte [] aEncodedBuffer,
                    @Nonnegative final int nOfs,
                    @Nonnegative final int nLen,
                    @Nonnull @WillNotClose final OutputStream aOS)
{
  if (aEncodedBuffer == null || nLen == 0)
    return;

  try (final GZIPInputStream aDecodeIS = new GZIPInputStream (new NonBlockingByteArrayInputStream (aEncodedBuffer,
                                                                                                   nOfs,
                                                                                                   nLen)))
  {
    if (StreamHelper.copyInputStreamToOutputStream (aDecodeIS, aOS).isFailure ())
      throw new DecodeException ("Failed to GZIP decode!");
  }
  catch (final IOException ex)
  {
    throw new DecodeException ("Failed to GZIP encode", ex);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
public void encode (@Nullable final byte [] aDecodedBuffer,
                    @Nonnegative final int nOfs,
                    @Nonnegative final int nLen,
                    @Nonnull @WillNotClose final OutputStream aOS)
{
  if (aDecodedBuffer == null || nLen == 0)
    return;

  try (final GZIPOutputStream aEncodeOS = new GZIPOutputStream (new NonClosingOutputStream (aOS)))
  {
    if (StreamHelper.copyInputStreamToOutputStream (new NonBlockingByteArrayInputStream (aDecodedBuffer, nOfs, nLen),
                                                    aEncodeOS)
                    .isFailure ())
      throw new EncodeException ("Failed to GZIP encode!");
  }
  catch (final IOException ex)
  {
    throw new EncodeException ("Failed to GZIP encode", ex);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
public void decode (@Nullable final byte [] aEncodedBuffer,
                    @Nonnegative final int nOfs,
                    @Nonnegative final int nLen,
                    @Nonnull @WillNotClose final OutputStream aOS)
{
  if (aEncodedBuffer == null || nLen == 0)
    return;

  if (!isZlibHead (aEncodedBuffer, nOfs, nLen))
    s_aLogger.warn ("ZLib header not found");

  try (final InflaterInputStream aDecodeIS = new InflaterInputStream (new NonBlockingByteArrayInputStream (aEncodedBuffer,
                                                                                                           nOfs,
                                                                                                           nLen)))
  {
    if (StreamHelper.copyInputStreamToOutputStream (aDecodeIS, aOS).isFailure ())
      throw new DecodeException ("Failed to flate decode!");
  }
  catch (final IOException ex)
  {
    throw new DecodeException ("Failed to flate encode", ex);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
public void encode (@Nullable final byte [] aDecodedBuffer,
                    @Nonnegative final int nOfs,
                    @Nonnegative final int nLen,
                    @Nonnull @WillNotClose final OutputStream aOS)
{
  if (aDecodedBuffer == null || nLen == 0)
    return;

  try (final DeflaterOutputStream aEncodeOS = new DeflaterOutputStream (new NonClosingOutputStream (aOS)))
  {
    if (StreamHelper.copyInputStreamToOutputStream (new NonBlockingByteArrayInputStream (aDecodedBuffer, nOfs, nLen),
                                                    aEncodeOS)
                    .isFailure ())
      throw new EncodeException ("Failed to flate encode!");
  }
  catch (final IOException ex)
  {
    throw new EncodeException ("Failed to flate encode", ex);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * Check if the passed reader can be resembled to valid CSS content. This is
 * accomplished by fully parsing the CSS each time the method is called. This
 * is similar to calling
 * {@link #readFromStream(IHasInputStream, Charset, ECSSVersion)} and checking
 * for a non-<code>null</code> result.
 *
 * @param aReader
 *        The reader to use. May not be <code>null</code>.
 * @param eVersion
 *        The CSS version to use. May not be <code>null</code>.
 * @return <code>true</code> if the CSS is valid according to the version,
 *         <code>false</code> if not
 */
public static boolean isValidCSS (@Nonnull @WillClose final Reader aReader, @Nonnull final ECSSVersion eVersion)
{
  ValueEnforcer.notNull (aReader, "Reader");
  ValueEnforcer.notNull (eVersion, "Version");

  try
  {
    final CSSCharStream aCharStream = new CSSCharStream (aReader);
    final CSSNode aNode = _readStyleSheet (aCharStream,
                                           eVersion,
                                           getDefaultParseErrorHandler (),
                                           new DoNothingCSSParseExceptionCallback (),
                                           false);
    return aNode != null;
  }
  finally
  {
    StreamHelper.close (aReader);
  }
}
 

import com.helger.commons.io.stream.StreamHelper; //导入依赖的package包/类
/**
 * 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;
}