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.jnode.util.ReaderInputStream

    public void testBadUnicode2() throws Exception {
        char[] chars = new char[] {'a', '\ud800'};
        final String LINE = new String(chars);
        try {
            Reader r = new StringReader(LINE.substring(1));
            ReaderInputStream ris = new ReaderInputStream(r, "UTF-8");
            InputStreamReader isr = new InputStreamReader(ris);
            isr.read();
            Assert.fail("No exception raised");
        } catch (MalformedInputException ex) {
            // expected
        }


        Reader r = new StringReader(LINE.substring(0, 1));
        ReaderInputStream ris = new ReaderInputStream(r, "UTF-8");
        InputStreamReader isr = new InputStreamReader(ris);
        Assert.assertEquals(chars[0], isr.read());
    }

View Full Code Here

Examples of org.jruby.embed.io.ReaderInputStream

     * Test of available method, of class ReaderInputStream.
     */
    @Test
    public void testAvailable() throws Exception {
        logger1.info("available");
        ReaderInputStream instance = new ReaderInputStream(new FileReader(filename));
        int expResult = 40;
        int result = instance.available();
        assertEquals(expResult, result);
        instance.close();
    }

View Full Code Here

Examples of org.netbeans.gradle.project.output.ReaderInputStream

                Arrays.asList(taskDef.getStdErrListener(project)),
                errorConsumers));


        buildLauncher.setStandardOutput(new WriterOutputStream(forwardedStdOut));
        buildLauncher.setStandardError(new WriterOutputStream(forwardedStdErr));
        buildLauncher.setStandardInput(new ReaderInputStream(tab.getIo().getInRef()));


        return new OutputRef(forwardedStdOut, forwardedStdErr);
    }

View Full Code Here

Examples of org.restlet.engine.io.ReaderInputStream

            buf.append(Integer.toString(i)).append('-');
        }


        String s = buf.toString();
        Reader r = new StringReader(s);
        InputStream is = new ReaderInputStream(r);


        InputRepresentation ir = new InputRepresentation(is);
        ir.setCharacterSet(CharacterSet.ISO_8859_1);


        assertEquals("Value", s, ir.getText());

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

          break;
        
        case PG_TYPE_TEXT:
          Clob clob = rs.getClob(column);
          if (clob != null) {
            bytes = ObjectConverterUtil.convertToByteArray(new ReaderInputStream(clob.getCharacterStream(), this.encoding), this.maxLobSize);
          }              
          break;
          
        case PG_TYPE_BYTEA:
          Blob blob = rs.getBlob(column);

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

          streams.add(((SQLXMLImpl)obj).getBinaryStream());
            StreamFactoryReference sfr = new SQLXMLImpl();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof ClobImpl) {
            streams.add(new ReaderInputStream(((ClobImpl)obj).getCharacterStream(), Charset.forName(Streamable.ENCODING)));
            StreamFactoryReference sfr = new ClobImpl();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof BlobImpl) {
            streams.add(((Blob)obj).getBinaryStream());
            StreamFactoryReference sfr = new BlobImpl();
            references.add(sfr);
            return sfr;
          }
        } catch (SQLException e) {
          throw new IOException(e);
        }
      }
      else if (obj instanceof Serializable) {
        return obj;
      }
      else {
      try {
          if (obj instanceof Reader) {
            streams.add(new ReaderInputStream((Reader)obj, Charset.forName(Streamable.ENCODING)));
            StreamFactoryReference sfr = new SerializableReader();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof InputStream) {
            streams.add((InputStream)obj);
            StreamFactoryReference sfr = new SerializableInputStream();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof SQLXML) {
          streams.add(((SQLXML)obj).getBinaryStream());
            StreamFactoryReference sfr = new SQLXMLImpl();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof Clob) {
            streams.add(new ReaderInputStream(((Clob)obj).getCharacterStream(), Charset.forName(Streamable.ENCODING)));
            StreamFactoryReference sfr = new ClobImpl();
            references.add(sfr);
            return sfr;
          } else if (obj instanceof Blob) {
            streams.add(((Blob)obj).getBinaryStream());

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

    }
      
      @Override
      public InputStream getInputStream() throws IOException {
        try {
        return new ReaderInputStream(clob.getCharacterStream(), charset);
      } catch (SQLException e) {
        throw new IOException(e);
      }
      }

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

     * @return an ascii stream containing the <code>CLOB</code> data
     * @exception SQLException if there is an error accessing the
     * <code>CLOB</code> value
     */
    public InputStream getAsciiStream() throws SQLException {
      return new ReaderInputStream(getCharacterStream(), Charset.forName("US-ASCII")); //$NON-NLS-1$
    }

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

    private ClobStreamProvider(Clob searchstr) {
      this.searchstr = searchstr;
    }


    public InputStream getBinaryStream() throws SQLException {
      ReaderInputStream ris = new ReaderInputStream(searchstr.getCharacterStream(), Charset.forName("UTF-16")); //$NON-NLS-1$
      try {
        ris.skip(2);
        return ris;
      } catch (IOException e) {
        throw new SQLException(e);
      }
    }

View Full Code Here

Examples of org.teiid.core.util.ReaderInputStream

    FileStore fs = buffMgr.createFileStore("temp");
    
    ClobType clob = new ClobType(new ClobImpl(new InputStreamFactory() {
      @Override
      public InputStream getInputStream() throws IOException {
        return new ReaderInputStream(new StringReader("Clob contents One"),  Charset.forName(Streamable.ENCODING)); 
      }
      
    }, -1));
    
    BlobType blob = new BlobType(new BlobImpl(new InputStreamFactory() {
      @Override
      public InputStream getInputStream() throws IOException {
        return new ReaderInputStream(new StringReader("Blob contents Two"),  Charset.forName(Streamable.ENCODING));
      }
      
    }));    
    
    LobManager lobManager = new LobManager();

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.