Examples of ReaderInputStream

com.dotcms.repackage.org.apache.commons.io.input.ReaderInputStream
com.github.dandelion.core.utils.ReaderInputStream
{@link InputStream} implementation that reads a character stream from a {@link Reader}and transforms it to a byte stream using a specified charset encoding. The stream is transformed using a {@link CharsetEncoder} object, guaranteeing that all charsetencodings supported by the JRE are handled correctly. In particular for charsets such as UTF-16, the implementation ensures that one and only one byte order marker is produced.
Since in general it is not possible to predict the number of characters to be read from the {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the {@link Reader} are buffered. There is therefore no well defined correlationbetween the current position of the {@link Reader} and that of the {@link ReaderInputStream}. This also implies that in general there is no need to wrap the underlying {@link Reader}in a {@link java.io.BufferedReader}.
{@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader}; in the following example, reading from in2 would return the same byte sequence as reading from in (provided that the initial byte sequence is legal with respect to the charset encoding):
```
 InputStream in = ... Charset cs = ... InputStreamReader reader = new InputStreamReader(in, cs); ReaderInputStream in2 = new ReaderInputStream(reader, cs);
```
{@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,while {@link ReaderInputStream} pulls it from the underlying stream.
Note that while there are use cases where there is no alternative to using this class, very often the need to use this class is an indication of a flaw in the design of the code. This class is typically used in situations where an existing API only accepts an {@link InputStream}, but where the most natural way to produce the data is as a character stream, i.e. by providing a {@link Reader} instance. An example of a situationwhere this problem may appear is when implementing the {@link javax.activation.DataSource}interface from the Java Activation Framework.
Given the fact that the {@link Reader} class doesn't provide any way to predict whether the nextread operation will block or not, it is not possible to provide a meaningful implementation of the {@link InputStream#available()} method. A call to this methodwill always return 0. Also, this class doesn't support {@link InputStream#mark(int)}.
Instances of {@link ReaderInputStream} are not thread safe. @see org.apache.commons.io.output.WriterOutputStream @since 2.0
com.ibatis.common.io.ReaderInputStream
An InputStream backed by a Reader
com.ibm.commons.util.io.ReaderInputStream
InputStream that reads its data from a reader. @ibm-api
de.timefinder.core.util.ReaderInputStream
alargumentexception.blogspot.com/2009/05/java-rough-guide-to-character-encoding.html#javaencoding_stringclass Got source via: http://stackoverflow.com/questions/62241/how-to-convert-a-reader-to-inputstream-and-a-writer-to-outputstream
edu.stanford.nlp.io.ReaderInputStream
Adapts a Reader as an InputStream. Adapted from StringInputStream.
org.apache.any23.util.ReaderInputStream
Adapts a Reader as an InputStream. Adapted from StringInputStream.
org.apache.axis2.transport.base.streams.ReaderInputStream
{@link InputStream} implementation that reads a character stream from a {@link Reader}and transforms it to a byte stream using a specified charset encoding. The stream is transformed using a {@link CharsetEncoder} object, guaranteeing that all charsetencodings supported by the JRE are handled correctly. In particular for charsets such as UTF-16, the implementation ensures that one and only one byte order marker is produced.
Since in general it is not possible to predict the number of characters to be read from the {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the {@link Reader} are buffered. There is therefore no well defined correlationbetween the current position of the {@link Reader} and that of the {@link ReaderInputStream}. This also implies that in general there is no need to wrap the underlying {@link Reader}in a {@link java.io.BufferedReader}.
{@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader}; in the following example, reading from in2 would return the same byte sequence as reading from in (provided that the initial byte sequence is legal with respect to the charset encoding):
```
 InputStream in = ... Charset cs = ... InputStreamReader reader = new InputStreamReader(in, cs); ReaderInputStream in2 = new ReaderInputStream(reader, cs);
```
{@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,while {@link ReaderInputStream} pulls it from the underlying stream.
Note that while there are use cases where there is no alternative to using this class, very often the need to use this class is an indication of a flaw in the design of the code. This class is typically used in situations where an existing API only accepts an {@link InputStream}, but where the most natural way to produce the data is as a character stream, i.e. by providing a {@link Reader} instance. An example of a situationwhere this problem may appear is when implementing the {@link javax.activation.DataSource}interface from the Java Activation Framework.
Given the fact that the {@link Reader} class doesn't provide any way to predict whether the nextread operation will block or not, it is not possible to provide a meaningful implementation of the {@link InputStream#available()} method. A call to this methodwill always return 0. Also, this class doesn't support {@link InputStream#mark(int)}.
Instances of {@link ReaderInputStream} are not thread safe.
org.apache.commons.io.input.ReaderInputStream
{@link InputStream} implementation that reads a character stream from a {@link Reader}and transforms it to a byte stream using a specified charset encoding. The stream is transformed using a {@link CharsetEncoder} object, guaranteeing that all charsetencodings supported by the JRE are handled correctly. In particular for charsets such as UTF-16, the implementation ensures that one and only one byte order marker is produced.
Since in general it is not possible to predict the number of characters to be read from the {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the {@link Reader} are buffered. There is therefore no well defined correlationbetween the current position of the {@link Reader} and that of the {@link ReaderInputStream}. This also implies that in general there is no need to wrap the underlying {@link Reader}in a {@link java.io.BufferedReader}.
{@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader}; in the following example, reading from in2 would return the same byte sequence as reading from in (provided that the initial byte sequence is legal with respect to the charset encoding):
```
 InputStream in = ... Charset cs = ... InputStreamReader reader = new InputStreamReader(in, cs); ReaderInputStream in2 = new ReaderInputStream(reader, cs);
```
{@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,while {@link ReaderInputStream} pulls it from the underlying stream.
Note that while there are use cases where there is no alternative to using this class, very often the need to use this class is an indication of a flaw in the design of the code. This class is typically used in situations where an existing API only accepts an {@link InputStream}, but where the most natural way to produce the data is as a character stream, i.e. by providing a {@link Reader} instance. An example of a situationwhere this problem may appear is when implementing the {@link javax.activation.DataSource}interface from the Java Activation Framework.
Given the fact that the {@link Reader} class doesn't provide any way to predict whether the nextread operation will block or not, it is not possible to provide a meaningful implementation of the {@link InputStream#available()} method. A call to this methodwill always return 0. Also, this class doesn't support {@link InputStream#mark(int)}.
Instances of {@link ReaderInputStream} are not thread safe. @see org.apache.commons.io.output.WriterOutputStream @author Andreas Veithen @since Commons IO 2.0
org.apache.james.fetchmail.ReaderInputStream
Simple class to allow a cast from a java.io.Reader to a java.io.InputStream $Id: ReaderInputStream.java,v 1.4.2.3 2004/02/11 17:17:07 sbrewin Exp $
org.apache.tools.ant.util.ReaderInputStream
Adapts a Reader as an InputStream. Adapted from StringInputStream.
org.apache.xmlbeans.impl.common.ReaderInputStream
org.atmosphere.util.ReaderInputStream
{@link java.io.InputStream} implementation that reads a character stream from a {@link java.io.Reader}and transforms it to a byte stream using a specified charset encoding. The stream is transformed using a {@link java.nio.charset.CharsetEncoder} object, guaranteeing that all charsetencodings supported by the JRE are handled correctly. In particular for charsets such as UTF-16, the implementation ensures that one and only one byte order marker is produced.
Since in general it is not possible to predict the number of characters to be read from the {@link java.io.Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the {@link java.io.Reader} are buffered. There is therefore no well defined correlationbetween the current position of the {@link java.io.Reader} and that of the {@link ReaderInputStream}. This also implies that in general there is no need to wrap the underlying {@link java.io.Reader}in a {@link java.io.BufferedReader}.
{@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader}; in the following example, reading from in2 would return the same byte sequence as reading from in (provided that the initial byte sequence is legal with respect to the charset encoding):
```
 InputStream in = ... Charset cs = ... InputStreamReader reader = new InputStreamReader(in, cs); ReaderInputStream in2 = new ReaderInputStream(reader, cs);
```
{@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,while {@link ReaderInputStream} pulls it from the underlying stream.Note that while there are use cases where there is no alternative to using this class, very often the need to use this class is an indication of a flaw in the design of the code. This class is typically used in situations where an existing API only accepts an {@link java.io.InputStream}, but where the most natural way to produce the data is as a character stream, i.e. by providing a {@link java.io.Reader} instance. An example of a situationwhere this problem may appear is when implementing the {@link javax.activation.DataSource}interface from the Java Activation Framework. Given the fact that the {@link java.io.Reader} class doesn't provide any way to predict whether the nextread operation will block or not, it is not possible to provide a meaningful implementation of the {@link java.io.InputStream#available()} method. A call to this methodwill always return 0. Also, this class doesn't support {@link java.io.InputStream#mark(int)}. Instances of {@link ReaderInputStream} are not thread safe.
org.atmosphere.wasync.util.ReaderInputStream
{@link InputStream} implementation that reads a character stream from a {@link Reader}and transforms it to a byte stream using a specified charset encoding. The stream is transformed using a {@link CharsetEncoder} object, guaranteeing that all charsetencodings supported by the JRE are handled correctly. In particular for charsets such as UTF-16, the implementation ensures that one and only one byte order marker is produced.
Since in general it is not possible to predict the number of characters to be read from the {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the {@link Reader} are buffered. There is therefore no well defined correlationbetween the current position of the {@link Reader} and that of the {@link ReaderInputStream}. This also implies that in general there is no need to wrap the underlying {@link Reader}in a {@link java.io.BufferedReader}.
{@link ReaderInputStream} implements the inverse transformation of {@link java.io.InputStreamReader}; in the following example, reading from in2 would return the same byte sequence as reading from in (provided that the initial byte sequence is legal with respect to the charset encoding):
```
 InputStream in = ... Charset cs = ... InputStreamReader reader = new InputStreamReader(in, cs); ReaderInputStream in2 = new ReaderInputStream(reader, cs);
```
{@link ReaderInputStream} implements the same transformation as {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes data to the underlying stream,while {@link ReaderInputStream} pulls it from the underlying stream.Note that while there are use cases where there is no alternative to using this class, very often the need to use this class is an indication of a flaw in the design of the code. This class is typically used in situations where an existing API only accepts an {@link InputStream}, but where the most natural way to produce the data is as a character stream, i.e. by providing a {@link Reader} instance. An example of a situationwhere this problem may appear is when implementing the {@link javax.activation.DataSource}interface from the Java Activation Framework. Given the fact that the {@link Reader} class doesn't provide any way to predict whether the nextread operation will block or not, it is not possible to provide a meaningful implementation of the {@link InputStream#available()} method. A call to this methodwill always return 0. Also, this class doesn't support {@link InputStream#mark(int)}. Instances of {@link ReaderInputStream} are not thread safe.
org.drools.core.io.impl.ReaderInputStream
org.g4studio.core.orm.xibatis.common.io.ReaderInputStream
An InputStream backed by a Reader
org.h2.dev.util.ReaderInputStream
The reader input stream wraps a reader and convert the character to the UTF-8 format.
org.hibernate.lob.ReaderInputStream
Exposes a Reader as an InputStream @author Gavin King
org.hsqldb.lib.ReaderInputStream
This class is an part implementation of DataInput. It wraps a Reader object. @author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0
org.hsqldb_voltpatches.lib.ReaderInputStream
This class is an part implementation of DataInput. It wraps a Reader object. @author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0
org.jnode.util.ReaderInputStream
This class wraps a Reader with the InputStream API. It is used internally by the JNode shell, and is not recommended for general use. @author crawley@jnode.org
org.jruby.embed.io.ReaderInputStream
A ReaderInputStream converts java.io.Reader to java.io.InputStream. The ReaderInputStream reads data in a given Reader object into its internal buffer so that users of this class can access the file that Reader read by using methods defined in java.io.InputStream. @author Yoko Harada
org.netbeans.gradle.project.output.ReaderInputStream
org.restlet.engine.io.ReaderInputStream
Input stream based on a reader. The implementation relies on the NIO {@link CharsetEncoder} class. @author Jerome Louvel
org.teiid.core.util.ReaderInputStream
Implements a buffered {@link InputStream} for a given {@link Reader} and {@link Charset}
org.tuba.util.ReaderInputStream
@author Jan Reimann (janreimone@gmail.com)
org.wymiwyg.rwcf.impl.ReaderInputStream
Adapts a Reader as an InputStream. Adapted from StringInputStream.

Examples of com.dotcms.repackage.org.apache.commons.io.input.ReaderInputStream

          }
          else if(compressor.equals("bzip2")) {
            out = new BZip2CompressorOutputStream(out);
          }


          ReaderInputStream ris = null;


          try {
            int count;
            ris = new ReaderInputStream(fulltext, StandardCharsets.UTF_8);


            int metadataLimit = Config.getIntProperty("META_DATA_MAX_SIZE", 5) * 1024 * 1024;
            int numOfChunks = metadataLimit / 1024;


            char[] buf = new char[1024];
            byte[] bytes = new byte[1024];


            while ((count = fulltext.read(buf)) > 0 && numOfChunks>0) {
              String lowered = new String(buf);
              lowered = lowered.toLowerCase();
              bytes = lowered.getBytes(StandardCharsets.UTF_8);
              out.write(bytes, 0, count);
              numOfChunks --;
            }
          }catch(IOException ioExc){
            Logger.debug( this.getClass(), "Error Reading TikaParse Stream.", ioExc );
          }finally {
            if ( out != null ) {
              try {
                out.close();
              } catch ( IOException e ) {
                Logger.warn( this.getClass(), "Error Closing Stream.", e );
              }
            }


            if ( ris != null ) {
              try {
                ris.close();
              } catch ( IOException e ) {
                Logger.warn( this.getClass(), "Error Closing Stream.", e );
              }
            }

View Full Code Here

Examples of com.github.dandelion.core.utils.ReaderInputStream

  /**
   * {@inheritDoc}
   */
  @Override
  public void doProcess(Reader reader, Writer writer, ProcessingContext processingContext) throws Exception {
    InputStream is = new ReaderInputStream(reader, processingContext.getContext().getConfiguration()
        .getAssetProcessorEncoding());
    OutputStream os = new WriterOutputStream(writer, processingContext.getContext().getConfiguration()
        .getAssetProcessorEncoding());
    try {
      new JSMin(is, os).jsmin();
    }
    catch (Exception e) {
      throw e;
    }
    finally {
      is.close();
      os.close();
    }
  }

View Full Code Here

Examples of com.ibatis.common.io.ReaderInputStream

      DocumentBuilder db = dbf.newDocumentBuilder();
      db.setErrorHandler(new SimpleErrorHandler(new PrintWriter(errorWriter, true)));
      db.setEntityResolver(new DaoClasspathEntityResolver());


      // Parse input file
      Document doc = db.parse(new ReaderInputStream(reader));
      return doc;
    } catch (Exception e) {
      throw new NestedRuntimeException("XML Parser Error.  Cause: " + e);
    }
  }

View Full Code Here

Examples of com.ibatis.common.io.ReaderInputStream


  private Document stringToDocument (String s) {
    try {
      DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
      return documentBuilder.parse(new ReaderInputStream(new StringReader(s)));
    } catch (Exception e) {
      throw new NestedRuntimeException("Error occurred.  Cause: " + e, e);
    }
  }

View Full Code Here

Examples of com.ibatis.common.io.ReaderInputStream

      DocumentBuilder db = dbf.newDocumentBuilder();
      db.setErrorHandler(new SimpleErrorHandler(new PrintWriter(errorWriter, true)));
      db.setEntityResolver(new DaoClasspathEntityResolver());


      // Parse input file
      Document doc = db.parse(new ReaderInputStream(reader));
      return doc;
    } catch (Exception e) {
      throw new NestedRuntimeException("XML Parser Error.  Cause: " + e);
    }
  }

View Full Code Here

Examples of com.ibm.commons.util.io.ReaderInputStream

   * Decide whether a node should be included in the tree.
   * @param properties
   * @return True if this node is to be included, false if it should not be included in the tree.
   */
  protected boolean includeNode(String properties) {
        ReaderInputStream is = new ReaderInputStream(new StringReader(properties));
        Properties p = new Properties();
        try {
            p.load(is);
        } catch (IOException e) {
            e.printStackTrace();

View Full Code Here

Examples of com.ibm.commons.util.io.ReaderInputStream

      addProperties(p, props);
    }
  }
  protected void addProperties(Properties p, String value) throws IOException {
    if(StringUtil.isNotEmpty(value)) {
      ReaderInputStream is = new ReaderInputStream(new StringReader(value));
      try {
        p.load(is);
      } finally {
        StreamUtil.close(is);
      }

View Full Code Here

Examples of com.ibm.commons.util.io.ReaderInputStream

   */
  public static Property[] parseProperties(String sProperty) throws IOException {
    if(StringUtil.isNotEmpty(sProperty)) {
      Properties props = new Properties();
      StringReader r = new StringReader(sProperty);
      props.load(new ReaderInputStream(r));
      List<Property> properties = new ArrayList<Property>();
      for(Entry<Object, Object> e: props.entrySet()) {
        Property p = new Property((String)e.getKey(),(String)e.getValue());
        properties.add(p);
      }

View Full Code Here

Examples of com.ibm.commons.util.io.ReaderInputStream

      return null;
    }
  }
  private static byte[] decodeBase64(String s) {
    try {
      Base64.InputStream b64 = new Base64.InputStream(new ReaderInputStream(new StringReader(s)));
      ByteBuffer bb = ByteBuffer.allocate(1024*4); // max cookie size
      int byt;
      while( (byt = b64.read()) >= 0)  {
        bb.put((byte) (byt&0xFF));
      }

View Full Code Here

Examples of com.ibm.commons.util.io.ReaderInputStream

                    url = new URL(resourcesXmlVal);
                    // log the fact that we picked up an URL?
                    logMsgs.add("Found a valid URL to global resources descriptor. Accessing URL now..."); // $NLI-WebAppServerPlatform.FoundavalidURLtoglobalresourcesde-1$
                    return url.openStream();
                } catch( MalformedURLException ex) {
                    return new ReaderInputStream(new StringReader(resourcesXmlVal));
                } catch (IOException e) {
                    // log that URL access failed
                    logMsgs.add("IOException while accessing the URL to global resources descriptor."); // $NLE-WebAppServerPlatform.IOExceptionwhileaccessingtheURLto-1$
                }

View Full Code Here

0 1 2 3 4 5 6

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.