content: package com.bj58.argo.thirdparty.jetty;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.io.Reader;
  import java.io.StringWriter;
  import java.io.Writer;
  
  
  /* ======================================================================== */
  /** IO Utilities.
   * Provides stream handling utilities in
   * singleton Threadpool implementation accessed by static members.
   */
  public class IO 
  {
      /* ------------------------------------------------------------------- */
      public final static String
          CRLF      = "\015\012";
  
      /* ------------------------------------------------------------------- */
      public final static byte[]
          CRLF_BYTES    = {(byte)'\015',(byte)'\012'};
  
      /* ------------------------------------------------------------------- */
      public static int bufferSize = 64*1024;
  
      
      /* ------------------------------------------------------------------- */
      /** Copy Stream in to Stream out until EOF or exception.
       */
      public static void copy(InputStream in, OutputStream out)
           throws IOException
      {
          copy(in,out,-1);
      }
      
  
      
      /* ------------------------------------------------------------------- */
      /** Copy Reader to Writer out until EOF or exception.
       */
      public static void copy(Reader in, Writer out)
           throws IOException
      {
          copy(in,out,-1);
      }
      
      /* ------------------------------------------------------------------- */
      /** Copy Stream in to Stream for byteCount bytes or until EOF or exception.
       */
      public static void copy(InputStream in,
                              OutputStream out,
                              long byteCount)
           throws IOException
      {     
          byte buffer[] = new byte[bufferSize];
          int len=bufferSize;
          
          if (byteCount>=0)
          {
              while (byteCount>0)
              {
                  int max = byteCount<bufferSize?(int)byteCount:bufferSize;
                  len=in.read(buffer,0,max);
                  
                  if (len==-1)
                      break;
                  
                  byteCount -= len;
                  out.write(buffer,0,len);
              }
          }
          else
          {
              while (true)
              {
                  len=in.read(buffer,0,bufferSize);
                  if (len<0 )
                      break;
                  out.write(buffer,0,len);
              }
          }
      }  
      
      /* ------------------------------------------------------------------- */
      /** Copy Reader to Writer for byteCount bytes or until EOF or exception.
       */
      public static void copy(Reader in,
                              Writer out,
                              long byteCount)
           throws IOException
      {  
          char buffer[] = new char[bufferSize];
          int len=bufferSize;
          
          if (byteCount>=0)
          {
              while (byteCount>0)
              {
                  if (byteCount<bufferSize)
                      len=in.read(buffer,0,(int)byteCount);
                  else
                      len=in.read(buffer,0,bufferSize);                   
                  
                  if (len==-1)
                      break;
                  
                  byteCount -= len;
                  out.write(buffer,0,len);
              }
          }
          else if (out instanceof PrintWriter)
          {
              PrintWriter pout=(PrintWriter)out;
              while (!pout.checkError())
              {
                  len=in.read(buffer,0,bufferSize);
                  if (len==-1)
                      break;
                  out.write(buffer,0,len);
              }
          }
          else
          {
              while (true)
              {
                  len=in.read(buffer,0,bufferSize);
                  if (len==-1)
                      break;
                  out.write(buffer,0,len);
              }
          }
      }
  
      /* ------------------------------------------------------------ */
      /** Copy files or directories
       * @param from
       * @param to
       * @throws IOException
       */
      public static void copy(File from,File to) throws IOException
      {
          if (from.isDirectory())
              copyDir(from,to);
          else
              copyFile(from,to);
      }
  
      /* ------------------------------------------------------------ */
      public static void copyDir(File from,File to) throws IOException
      {
          if (to.exists())
          {
              if (!to.isDirectory())
                  throw new IllegalArgumentException(to.toString());
          }
          else
              to.mkdirs();
          
          File[] files = from.listFiles();
          if (files!=null)
          {
              for (int i=0;i<files.length;i++)
              {
                  String name = files[i].getName();
                  if (".".equals(name) || "..".equals(name))
                      continue;
                  copy(files[i],new File(to,name));
              }
          }
      }
      
      /* ------------------------------------------------------------ */
      public static void copyFile(File from,File to) throws IOException
      {
          FileInputStream in=new FileInputStream(from);
          FileOutputStream out=new FileOutputStream(to);
          copy(in,out);
          in.close();
          out.close();
      }
      
      /* ------------------------------------------------------------ */
      /** Read input stream to string.
       */
      public static String toString(InputStream in)
          throws IOException
      {
          return toString(in,null);
      }
      
      /* ------------------------------------------------------------ */
      /** Read input stream to string.
       */
      public static String toString(InputStream in,String encoding)
          throws IOException
      {
          StringWriter writer=new StringWriter();
          InputStreamReader reader = encoding==null?new InputStreamReader(in):new InputStreamReader(in,encoding);
          
          copy(reader,writer);
          return writer.toString();
      }
      
      /* ------------------------------------------------------------ */
      /** Read input stream to string.
       */
      public static String toString(Reader in)
          throws IOException
      {
          StringWriter writer=new StringWriter();
          copy(in,writer);
          return writer.toString();
      }
  
  
      /* ------------------------------------------------------------ */
      /** Delete File.
       * This delete will recursively delete directories - BE CAREFULL
       * @param file The file to be deleted.
       */
      public static boolean delete(File file)
      {
          if (!file.exists())
              return false;
          if (file.isDirectory())
          {
              File[] files = file.listFiles();
              for (int i=0;files!=null && i<files.length;i++)
                  delete(files[i]);
          }
          return file.delete();
      }
  
      /* ------------------------------------------------------------ */
      /**
       * closes an input stream, and logs exceptions
       *
       * @param is the input stream to close
       */
      public static void close(InputStream is)
      {
          try
          {
              if (is != null)
                  is.close();
          }
          catch (IOException e)
          {
  
          }
      }
  
      /**
       * closes a reader, and logs exceptions
       * 
       * @param reader the reader to close
       */
      public static void close(Reader reader)
      {
          try
          {
              if (reader != null)
                  reader.close();
          } catch (IOException e)
          {
  
          }
      }
  
      /**
       * closes a writer, and logs exceptions
       * 
       * @param writer the writer to close
       */
      public static void close(Writer writer)
      {
          try
          {
              if (writer != null)
                  writer.close();
          } catch (IOException e)
          {
  
          }
      }
      
      /* ------------------------------------------------------------ */
      public static byte[] readBytes(InputStream in)
          throws IOException
      {
          ByteArrayOutputStream bout = new ByteArrayOutputStream();
          copy(in,bout);
          return bout.toByteArray();
      }
      
      /* ------------------------------------------------------------ */
      /**
       * closes an output stream, and logs exceptions
       *
       * @param os the output stream to close
       */
      public static void close(OutputStream os)
      {
          try
          {
              if (os != null)
                  os.close();
          }
          catch (IOException e)
          {
  
          }
      }
  
      /* ------------------------------------------------------------ */
      /** 
       * @return An outputstream to nowhere
       */
      public static OutputStream getNullStream()
      {
          return __nullStream;
      }
  
      /* ------------------------------------------------------------ */
      /** 
       * @return An outputstream to nowhere
       */
      public static InputStream getClosedStream()
      {
          return __closedStream;
      }
      
      /* ------------------------------------------------------------ */
      /* ------------------------------------------------------------ */
      private static class NullOS extends OutputStream                                    
      {
          @Override
          public void close(){}
          @Override
          public void flush(){}
          @Override
          public void write(byte[]b){}
          @Override
          public void write(byte[]b,int i,int l){}
          @Override
          public void write(int b){}
      }
      private static NullOS __nullStream = new NullOS();
  
      
      /* ------------------------------------------------------------ */
      /* ------------------------------------------------------------ */
      private static class ClosedIS extends InputStream                                    
      {
          @Override
          public int read() throws IOException
          {
              return -1;
          }
      }
      private static ClosedIS __closedStream = new ClosedIS();
      
      /* ------------------------------------------------------------ */
      /** 
       * @return An writer to nowhere
       */
      public static Writer getNullWriter()
      {
          return __nullWriter;
      }
      
      /* ------------------------------------------------------------ */
      /** 
       * @return An writer to nowhere
       */
      public static PrintWriter getNullPrintWriter()
      {
          return __nullPrintWriter;
      }
      
      /* ------------------------------------------------------------ */
      /* ------------------------------------------------------------ */
      private static class NullWrite extends Writer                                    
      {
          @Override
          public void close(){}
          @Override
          public void flush(){}
          @Override
          public void write(char[]b){}
          @Override
          public void write(char[]b,int o,int l){}
          @Override
          public void write(int b){}
          @Override
          public void write(String s){}
          @Override
          public void write(String s,int o,int l){}
      }
      private static NullWrite __nullWriter = new NullWrite();
      private static PrintWriter __nullPrintWriter = new PrintWriter(__nullWriter);
  }
  
  
  