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 org.teiid.core.util.ReaderInputStream

    ObjectEncoderOutputStream out = new ObjectEncoderOutputStream(new DataOutputStream(baos), 512);
    
    ClobImpl clob = new ClobImpl(new InputStreamFactory() {
      @Override
      public InputStream getInputStream() throws IOException {
        return new ReaderInputStream(new StringReader("Clob contents"),  Charset.forName(Streamable.ENCODING)); //$NON-NLS-1$
      }
      
    }, -1);
    
    out.writeObject(clob);

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

    }
    this.setObject(parameterIndex, new ClobImpl(new InputStreamFactory() {
      
      @Override
      public InputStream getInputStream() throws IOException {
        return new ReaderInputStream(reader, Charset.forName(Streamable.ENCODING));
      }
    }, -1));
  }

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

                XMLType xml = (XMLType)streamable;
                return new ByteLobChunkStream(xml.getBinaryStream(), chunkSize);
            }
            else if (streamable instanceof ClobType) {
                ClobType clob = (ClobType)streamable;
                return new ByteLobChunkStream(new ReaderInputStream(clob.getCharacterStream(), Charset.forName(Streamable.ENCODING)), chunkSize);            
            } 
            BlobType blob = (BlobType)streamable;
            return new ByteLobChunkStream(blob.getBinaryStream(), chunkSize);                        
        } catch(SQLException e) {
            throw new IOException(e);

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

          InputStream is = null;
          try {
            if (file instanceof SQLXML) {
              is = ((SQLXML)file).getBinaryStream();
            } else if (file instanceof Clob) {
              is = new ReaderInputStream(((Clob)file).getCharacterStream(), encoding);
            } else if (file instanceof Blob) {
              is = ((Blob)file).getBinaryStream();
            } else {
              throw new TranslatorException(UTIL.getString("unknown_type")); //$NON-NLS-1$
            }

View Full Code Here

Examples of org.tuba.util.ReaderInputStream

        return;
      }
      viewCursor.goToRange(textRange, false); 
      try {
        StringReader reader = new StringReader(textInfo.getText());
        InputStream is = new ReaderInputStream(reader);
        viewCursor.getTextCursorFromStart().insertDocument(is, RTFFilter.FILTER);
//        viewCursor.getTextCursorFromStart().insertDocument(is, HTMLFilter.FILTER);
      } catch (NOAException e) {
        e.printStackTrace();
      }

View Full Code Here

Examples of org.wymiwyg.rwcf.impl.ReaderInputStream

      if ((body instanceof byte[])) {
        in = new ByteArrayInputStream((byte[])body);
        
      } else {
        if ((body instanceof Reader)) {
          in = new ReaderInputStream((Reader)body);
          
        } else {
          throw new RuntimeException("Body of type "+body.getClass()+" not yet supported");
        }
      }

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.