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.ibm.commons.util.io.ReaderInputStream

  
  private void emit(HttpServletResponse resp, String text, String contentType) throws IOException {
    resp.setStatus(200);
    resp.setContentType(contentType);
    ByteStreamCache bs = new ByteStreamCache();
    InputStream is = new ReaderInputStream(new StringReader(text),"utf-8");
    bs.copyFrom(is);
    resp.setContentLength((int)bs.getLength());
    OutputStream os = resp.getOutputStream();
    bs.copyTo(os);
    os.flush();

View Full Code Here

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

          }
          if(StringUtil.isNotEmpty(sProperties)) {
          try {
            // Pass the properties from the file
            if(StringUtil.isNotEmpty(sProperties)) {
              this.properties.load(new ReaderInputStream(new StringReader(sProperties)));
            }
          } catch(Exception ex) {}
          }
        }

View Full Code Here

Examples of de.timefinder.core.util.ReaderInputStream

    private InputStream reader;
    private ObjectParsing objectParsing = new ObjectParsing();
    private Map<Class, Map<Long, DBInterface>> simpleDaos = FastMap.newInstance();


    XmlImport(DataPool pool, DataPoolSettings settings, Reader reader) {
        this(pool, settings, new ReaderInputStream(reader));
    }

View Full Code Here

Examples of edu.stanford.nlp.io.ReaderInputStream

    TreebankLanguagePack tlp = new SpanishTreebankLanguagePack();


    this.simplifiedTagset = simplifiedTagset;
    this.detailedAnnotations = detailedAnnotations;


    stream = new ReaderInputStream(in, tlp.getEncoding());
    treeFactory = new LabeledScoredTreeFactory();
    treeNormalizer =
      new SpanishTreeNormalizer(simplifiedTagset,
                                aggressiveNormalization,
                                retainNER);

View Full Code Here

Examples of org.apache.any23.util.ReaderInputStream

        return NQuads.FORMAT;
    }


    public void parse(Reader reader, String s)
    throws IOException, RDFParseException, RDFHandlerException {
        ReaderInputStream readerInputStream = new ReaderInputStream(reader);
        parse(readerInputStream, s);
    }

View Full Code Here

Examples of org.apache.axis2.transport.base.streams.ReaderInputStream

    public String getName() {
        return null;
    }


    public InputStream getInputStream() throws IOException {
        return new ReaderInputStream(ElementHelper.getTextAsStream(element, true), charset);
    }

View Full Code Here

Examples of org.apache.commons.io.input.ReaderInputStream


  @Override
  public void readFrom(Reader in, Syntax syntax, String baseURI)
      throws IOException, ModelRuntimeException,
      SyntaxNotSupportedException {
    ReaderInputStream is = new ReaderInputStream(in, StandardCharsets.UTF_8);
    readFrom(is, syntax, baseURI);
  }

View Full Code Here

Examples of org.apache.james.fetchmail.ReaderInputStream

            mail =
                new MailImpl(session.getConfigurationData().getMailServer().getId(),
                             (MailAddress) session.getState().get(SMTPSession.SENDER),
                             recipientCollection,
                             new SequenceInputStream(new SequenceInputStream(headersIn, msgIn),
                                     new ReaderInputStream(new StringReader("\r\n"))));
            // Call mail.getSize() to force the message to be
            // loaded. Need to do this to enforce the size limit
            if (session.getConfigurationData().getMaxMessageSize() > 0) {
                mail.getMessageSize();
            }

View Full Code Here

Examples of org.apache.tools.ant.util.ReaderInputStream


    /**
     * Transforms the given InputStream. The original InputStream will be closed by the returned InputStream.
     */
    public InputStream transform(InputStream original) {
        return new ReaderInputStream(transform(new InputStreamReader(original)));
    }

View Full Code Here

Examples of org.apache.tools.ant.util.ReaderInputStream

                    }
                }
                rdr = new MultiReader(Arrays.asList(readers).iterator(),
                        identityReaderFactory);
            }
            return outputEncoding == null ? new ReaderInputStream(rdr)
                    : new ReaderInputStream(rdr, outputEncoding);
        }

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.