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.apache.tools.ant.util.ReaderInputStream

                    helper.setProject(managingTask.getProject());
                    helper.setPrimaryReader(reader);
                    helper.setFilterChains(outputFilterChains);
                    reader = helper.getAssembledReader();
                }
                outPumpIn = new ReaderInputStream(reader, outputEncoding);


                Thread t = new Thread(threadGroup, new StreamPumper(
                    outPumpIn, outputStream, true), "output pumper");
                t.setPriority(Thread.MAX_PRIORITY);
                outputStream = new PipedOutputStream(snk);
                t.start();
            } catch (IOException eyeOhEx) {
                throw new BuildException(
                    "error setting up output stream", eyeOhEx);
            }
        }


        if ((errorFilterChains != null && errorFilterChains.size() > 0)
            || !(errorEncoding.equalsIgnoreCase(inputEncoding))) {
            try {
                LeadPipeInputStream snk = new LeadPipeInputStream();
                snk.setManagingComponent(managingTask);


                InputStream errPumpIn = snk;


                Reader reader = new InputStreamReader(errPumpIn, inputEncoding);


                if (errorFilterChains != null && errorFilterChains.size() > 0) {
                    ChainReaderHelper helper = new ChainReaderHelper();
                    helper.setProject(managingTask.getProject());
                    helper.setPrimaryReader(reader);
                    helper.setFilterChains(errorFilterChains);
                    reader = helper.getAssembledReader();
                }
                errPumpIn = new ReaderInputStream(reader, errorEncoding);


                Thread t = new Thread(threadGroup, new StreamPumper(
                    errPumpIn, errorStream, true), "error pumper");
                t.setPriority(Thread.MAX_PRIORITY);
                errorStream = new PipedOutputStream(snk);
                t.start();
            } catch (IOException eyeOhEx) {
                throw new BuildException(
                    "error setting up error stream", eyeOhEx);
            }
        }


        // if input files are specified, inputString and inputStream are ignored;
        // classes that work with redirector attributes can enforce
        // whatever warnings are needed
        if (input != null && input.length > 0) {
            managingTask.log("Redirecting input from file"
                + ((input.length == 1) ? "" : "s"), Project.MSG_VERBOSE);
            try {
                inputStream = new ConcatFileInputStream(input);
            } catch (IOException eyeOhEx) {
                throw new BuildException(eyeOhEx);
            }
            ((ConcatFileInputStream) inputStream).setManagingComponent(managingTask);
        } else if (inputString != null) {
            StringBuffer buf = new StringBuffer("Using input ");
            if (logInputString) {
                buf.append('"').append(inputString).append('"');
            } else {
                buf.append("string");
            }
            managingTask.log(buf.toString(), Project.MSG_VERBOSE);
            inputStream = new ByteArrayInputStream(inputString.getBytes());
        }


        if (inputStream != null
            && inputFilterChains != null && inputFilterChains.size() > 0) {
            ChainReaderHelper helper = new ChainReaderHelper();
            helper.setProject(managingTask.getProject());
            try {
                helper.setPrimaryReader(
                    new InputStreamReader(inputStream, inputEncoding));
            } catch (IOException eyeOhEx) {
                throw new BuildException(
                    "error setting up input stream", eyeOhEx);
            }
            helper.setFilterChains(inputFilterChains);
            inputStream = new ReaderInputStream(
                helper.getAssembledReader(), inputEncoding);
        }
    }

View Full Code Here

Examples of org.apache.xmlbeans.impl.common.ReaderInputStream


    public void actionPerformed(AnActionEvent anActionEvent) {
        try {
            String clipboardData = ClipboardUtil.getStringContent();
            if (clipboardData != null) {
                Document xmlDocument = CommonUtil.createXMLDocument(new ReaderInputStream(new StringReader(clipboardData), "UTF-8"));
                Element rootElement = xmlDocument.getRootElement();
                List<Element> configElements = rootElement.getChildren();
                ConnectionListModel model = (ConnectionListModel) list.getModel();
                int selectedIndex = list.getSelectedIndex();
                List<Integer> selectedIndexes = new ArrayList<Integer>();

View Full Code Here

Examples of org.atmosphere.util.ReaderInputStream

                    } catch (UnsupportedEncodingException e) {
                        logger.trace("", e);
                    }
                }
            } else {
                bis = new IS(new ReaderInputStream(b.reader));
            }
        }
        return bis;
    }

View Full Code Here

Examples of org.atmosphere.wasync.util.ReaderInputStream


        if (InputStream.class.isAssignableFrom(object.getClass())) {
            //TODO: Allow reading the response.
            return b.setBody((InputStream) object).execute();
        } else if (Reader.class.isAssignableFrom(object.getClass())) {
            return b.setBody(new ReaderInputStream((Reader) object)).execute();
        } else if (String.class.isAssignableFrom(object.getClass())) {
            return b.setBody((String) object).execute();
        } else if (byte[].class.isAssignableFrom(object.getClass())) {
            return b.setBody((byte[]) object).execute();
        } else {

View Full Code Here

Examples of org.drools.core.io.impl.ReaderInputStream

        ZipEntry entry;


        while ( ( entry = zis.getNextEntry() ) != null ) {
            final String entryName = entry.getName();
            if ( entryName.startsWith( prefix ) && entryName.endsWith( suffix ) ) {
                return new ReaderInputStream( new InputStreamReader( zis,
                                                                     "UTF-8" ) );
            }
        }


        throw new FileNotFoundException( "Could not find '" + prefix + "/*/" + suffix + "' in the jar." );

View Full Code Here

Examples of org.g4studio.core.orm.xibatis.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 RuntimeException("Error occurred.  Cause: " + e, e);
    }
  }

View Full Code Here

Examples of org.h2.dev.util.ReaderInputStream

    }


    public void test() throws Exception {
        String s = "\u00ef\u00f6\u00fc";
        StringReader r = new StringReader(s);
        InputStream in = new ReaderInputStream(r);
        byte[] buff = IOUtils.readBytesAndClose(in, 0);
        InputStream in2 = new ByteArrayInputStream(buff);
        Reader r2 = IOUtils.getBufferedReader(in2);
        String s2 = IOUtils.readStringAndClose(r2, Integer.MAX_VALUE);
        assertEquals(s, s2);

View Full Code Here

Examples of org.hibernate.lob.ReaderInputStream

    */
   public ProcessDefinition getPageflowDefinitionFromXml(String pageflowDefinition)
   {
      InputStream stream = null;
      try {
          stream = new ReaderInputStream(new StringReader(pageflowDefinition));
          return Jbpm.parseInputSource(new InputSource(stream));
      } finally {
          Resources.closeStream(stream);
      }       
   }

View Full Code Here

Examples of org.hibernate.lob.ReaderInputStream

    */
   public ProcessDefinition getProcessDefinitionFromXml(String processDefinition)
   {
       InputStream stream = null;
       try {
           stream = new ReaderInputStream(new StringReader(processDefinition));
           return ProcessDefinition.parseXmlInputStream(stream);
       } finally {
           Resources.closeStream(stream);
       }
   }

View Full Code Here

Examples of org.hibernate.lob.ReaderInputStream

    */
   public ProcessDefinition getPageflowDefinitionFromXml(String pageflowDefinition)
   {
      InputStream stream = null;
      try {
          stream = new ReaderInputStream(new StringReader(pageflowDefinition));
          return Jbpm.parseInputSource(new InputSource(stream));
      } finally {
          Resources.closeStream(stream);
      }       
   }

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.