Alias of {@link #copy(Reader, Writer, boolean)}
489899
public static int write(Reader reader, Writer writer, boolean closeWriter) {
        return copy(reader, writer, closeWriter);
    }
391646
public static void copy(InputStream is, Resource out, boolean closeIS) throws IOException {
	OutputStream os = null;
	try {
	    os = toBufferedOutputStream(out.getOutputStream());
	}
	catch (IOException ioe) {
	    IOUtil.closeEL(os);
	    throw ioe;
	}
	copy(is, os, closeIS, true);
    }
196654
public static int write(InputStream is, OutputStream os, boolean closeSink) {
        return copy(is, os, closeSink);
    }
1173584
public static Map<String, IDLProxyObject> create(Reader reader) throws IOException {
        return create(reader, false);
    }
607177
private static final void copy(Reader r, Writer w, long timeout) throws IOException {
	copy(r, w, 0xffff, timeout);
    }
771075
public static long copy(Reader reader, Writer writer, int bufferSize) throws IORuntimeException {
		return copy(reader, writer, bufferSize, null);
	}
428001
public static int copy(Reader in, Writer out) throws IOException {
        assert in != null : "No input Reader specified";
        assert out != null : "No output Writer specified";

        try {
            int byteCount = 0;
            char[] buffer = new char[BUFFER_SIZE];
            int bytesRead = -1;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
                byteCount += bytesRead;
            }
            out.flush();
            return byteCount;
        } finally {
            try {
                in.close();
            } catch (IOException ex) {
            }
            try {
                out.close();
            } catch (IOException ex) {
            }
        }
    }
802262
public static void copy(InputStream input,
      OutputStream output,
      int bufferSize)
      throws IOException {
    byte[] buf = new byte[bufferSize];
    int bytesRead = input.read(buf);
    while (bytesRead != -1) {
      output.write(buf, 0, bytesRead);
      bytesRead = input.read(buf);
    }
    output.flush();
  }
697993
public static void copy(InputStream input, Writer writer) throws IOException {
		copy(new InputStreamReader(input), writer);
	}
447312
public boolean markRead(boolean read) {
		if (PkRSS.getInstance() == null) return false;

		PkRSS.getInstance().markRead(id, read);
		return true;
	}
183839
public void write(Reader reader, boolean escape, boolean noBackslashEscapes) throws IOException {
    char[] buffer = new char[4096];
    int len;
    while ((len = reader.read(buffer)) >= 0) {
      byte[] data = new String(buffer, 0, len).getBytes("UTF-8");
      if (escape) {
        writeBytesEscaped(data, data.length, noBackslashEscapes);
      } else {
        write(data);
      }

    }
  }
1007520
public static boolean copy(File source, File destination) {
        boolean result = true;
        if (source.isDirectory()) {
            if (destination.exists()) {
                result = result && destination.isDirectory();
            } else {
                result = result && destination.mkdirs();
            }
            File[] children = source.listFiles();
            for (File element : children) {
                result =
                        result
                                && copy(new File(source, element.getName()),
                                        new File(destination, element.getName()));
            }
            return result;
        } else {
            try {
                InputStream in = new FileInputStream(source);
                OutputStream out = new FileOutputStream(destination);
                result = result && copy(in, out);
                in.close();
                out.close();
                return result;
            } catch (IOException e) {
                return false;
            }
        }
    }
1143999
public static void copy(XMLStreamReader reader, XMLStreamWriter writer) throws XMLStreamException {
        copy(reader, writer, false, false);
    }
502828
public static int copyAndCloseOutput(Reader input, Writer output) throws IOException {
		try {
			return copy(input, output);
		} finally {
			output.close();
		}
		
	}
1078939
public boolean isOverwrite() {
        Boolean booleanObject = BooleanUtils.toBooleanObject(System.getProperty(OVERWRITE));
        if (booleanObject == null) {
            booleanObject = Boolean.FALSE;
        }
        return booleanObject;
    }
537863
private int copy(final byte[] buffer, final byte[] response,
        final int read) {
        System.arraycopy(
            buffer, read - this.count, response, 0, this.count
        );
        return new MinOf(this.count, read).intValue();
    }
374894
public static void streamCopy(InputStream input, Writer output) throws IOException
	{
		if (input == null)
			throw new IllegalArgumentException("Must provide something to read from");
		if (output == null)
			throw new IllegalArgumentException("Must provide something to write to");

		streamCopy(new InputStreamReader(input), output);
	}