Esempio n. 1
1
  private static void testSysOut(String fs, String exp, Object... args) {
    FileOutputStream fos = null;
    FileInputStream fis = null;
    try {
      PrintStream saveOut = System.out;
      fos = new FileOutputStream("testSysOut");
      System.setOut(new PrintStream(fos));
      System.out.format(Locale.US, fs, args);
      fos.close();

      fis = new FileInputStream("testSysOut");
      byte[] ba = new byte[exp.length()];
      int len = fis.read(ba);
      String got = new String(ba);
      if (len != ba.length) fail(fs, exp, got);
      ck(fs, exp, got);

      System.setOut(saveOut);
    } catch (FileNotFoundException ex) {
      fail(fs, ex.getClass());
    } catch (IOException ex) {
      fail(fs, ex.getClass());
    } finally {
      try {
        if (fos != null) fos.close();
        if (fis != null) fis.close();
      } catch (IOException ex) {
        fail(fs, ex.getClass());
      }
    }
  }
Esempio n. 2
0
  public static FileDesc loadFile(Path root, Path file, int blocSize)
      throws NoSuchAlgorithmException, FileNotFoundException, IOException {
    MessageDigest md = MessageDigest.getInstance("SHA-512");
    MessageDigest fileMd = MessageDigest.getInstance("SHA-512");

    FileDesc desc = new FileDesc(file.toString(), null, null);
    List<Bloc> list = new ArrayList<Bloc>();
    try (FileInputStream fis = new FileInputStream(root.resolve(file).toString())) {
      byte[] buf = new byte[blocSize];
      byte[] h;
      int s;
      while ((s = fis.read(buf)) != -1) {
        int c;
        while (s < buf.length && (c = fis.read()) != -1) buf[s++] = (byte) c;
        fileMd.update(buf, 0, s);

        // padding
        byte p = 0;
        while (s < buf.length) buf[s++] = ++p;
        h = md.digest(buf);
        Bloc bloc = new Bloc(RollingChecksum.compute(buf), new Hash(h));
        list.add(bloc);
      }
      h = fileMd.digest();
      desc.fileHash = new Hash(h);
      desc.blocs = list.toArray(new Bloc[0]);
    }
    return desc;
  }
Esempio n. 3
0
 /**
  * Reads a line from the file.
  *
  * @return Line readed.
  */
 public String readLine() throws Exception {
   char c;
   String a = "";
   c = (char) fileInput.read();
   do {
     a = a + c;
     c = (char) fileInput.read();
   } while ((fileInput.available() != 0) && (c != '\n'));
   if (c != ' ') {
     a = a + c;
   }
   return a;
 }
  // pre : given file name is legal
  // post: creates a BitInputStream reading input from the file
  public BitInputStream(String file) {
    try {
      input = new FileInputStream(file);

      // Read in the number of remaining bits at the end
      this.remainingAtEnd = input.read();

      // Set up the nextByte field.
      this.nextByte = input.read();
    } catch (IOException e) {
      throw new RuntimeException(e.toString());
    }

    this.nextByte();
  }
Esempio n. 5
0
  /**
   * This method will read the standard input and save the content to a temporary. source file since
   * the source file will be parsed mutiple times. The HTML source file is parsed and checked for
   * Charset in HTML tags at first time, then source file is parsed again for the converting The
   * temporary file is read from standard input and saved in current directory and will be deleted
   * after the conversion has completed.
   *
   * @return the vector of the converted temporary source file name
   */
  public Vector getStandardInput() throws FileAccessException {
    byte[] buf = new byte[2048];
    int len = 0;
    FileInputStream fis = null;
    FileOutputStream fos = null;
    File tempSourceFile;
    String tmpSourceName = ".tmpSource_stdin";

    File outFile = new File(tmpSourceName);

    tempSourceFile = new File(System.getProperty("user.dir") + sep + tmpSourceName);
    if (!tempSourceFile.exists()) {
      try {
        fis = new FileInputStream(FileDescriptor.in);
        fos = new FileOutputStream(outFile);
        while ((len = fis.read(buf, 0, 2048)) != -1) fos.write(buf, 0, len);
      } catch (IOException e) {
        System.out.println(ResourceHandler.getMessage("plugin_converter.write_permission"));
        return null;
      }
    } else {
      throw new FileAccessException(ResourceHandler.getMessage("plugin_converter.overwrite"));
    }
    tempSourceFile = new File(System.getProperty("user.dir") + sep + tmpSourceName);
    if (tempSourceFile.exists()) {
      fileSpecs.add(tmpSourceName);
      return fileSpecs;
    } else {
      throw new FileAccessException(
          ResourceHandler.getMessage("plugin_converter.write_permission"));
    }
  }
Esempio n. 6
0
  public static void main(String args[]) {
    try {
      aServer asr = new aServer();

      // file channel.
      FileInputStream is = new FileInputStream("");
      is.read();
      FileChannel cha = is.getChannel();
      ByteBuffer bf = ByteBuffer.allocate(1024);
      bf.flip();

      cha.read(bf);

      // Path Paths
      Path pth = Paths.get("", "");

      // Files some static operation.
      Files.newByteChannel(pth);
      Files.copy(pth, pth);
      // file attribute, other different class for dos and posix system.
      BasicFileAttributes bas = Files.readAttributes(pth, BasicFileAttributes.class);
      bas.size();

    } catch (Exception e) {
      System.err.println(e);
    }

    System.out.println("hello ");
  }
 public void load() {
   if (!modelExists()) {
     loadError = "Cannot find " + LEVELS_DAT_FILE + ".";
     return;
   }
   File folder = new File(location);
   File dat = new File(folder, LEVELS_DAT_FILE);
   // File lst = new File(folder, LEVELS_LST_FILE);
   if (!dat.isFile()) return;
   ArrayList levels = new ArrayList();
   try {
     FileInputStream reader = new FileInputStream(dat);
     long fileLength = dat.length();
     int length = model.getField().getSize() + 96;
     int readLength = 0;
     byte[] buffer = new byte[length];
     while (fileLength - readLength >= length) {
       int toRead = length;
       while (toRead > 0) {
         toRead -= reader.read(buffer, length - toRead, toRead);
       }
       readLength += length;
       SupaplexLevel level = new SupaplexLevel();
       level.setModel(model);
       level.loadFromBytes(buffer);
       levels.add(level);
     }
     reader.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
   SupaplexLevel[] ls = (SupaplexLevel[]) levels.toArray(new SupaplexLevel[0]);
   model.setLevels(ls);
 }
 /**
  * @ensures: if input file is read, a String is filled with words from file and searched in
  *     dictionary list, and if found increase words found counter, otherwise increase words not
  *     found. Otherwise error reading file
  */
 public void readFileOliver() {
   try {
     FileInputStream inf = new FileInputStream(new File("oliver.txt"));
     char let;
     String str = "";
     String key = "";
     int n = 0;
     while ((n = inf.read()) != -1) {
       let = (char) n;
       if (Character.isLetter(let)) {
         str += Character.toLowerCase(let);
       }
       if ((Character.isWhitespace(let) || let == '-') && !str.isEmpty()) {
         key = str;
         str = "";
         boolean a = dictionary[(int) key.charAt(0) - 97].contains(key);
         if (a == true) {
           counter = dictionary[(int) key.charAt(0) - 97].indexOf(key);
           counterWFound++;
           counterWFCompared += counter;
         } else {
           counter =
               dictionary[(int) key.charAt(0) - 97].indexOf(
                   dictionary[(int) key.charAt(0) - 97].getLast());
           counterWNotFound++;
           counterWNFCompared += counter;
         }
       }
     }
     inf.close();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
 private Parser readContent() {
   Parser infoParser;
   String filename = FILE_READ_PATH + FILE_READ_BASE_NAME + "." + FILE_READ_EXT_NUM;
   FILE_READ_EXT_NUM++;
   try {
     File file = new File(filename);
     if (DEBUG)
       displayMessage(
           "DEBUG",
           "WCNForecastWeatherQueryFn.readContent:: File "
               + filename
               + " file.length="
               + file.length());
     byte bytes[] = new byte[(int) (file.length())];
     FileInputStream fis = new FileInputStream(file);
     int cnt = fis.read(bytes, 0, bytes.length);
     if (DEBUG)
       displayMessage(
           "DEBUG",
           "WCNForecastWeatherQueryFn.readContent:: File " + filename + " read cnt=" + cnt);
     fis.close();
     if (cnt != bytes.length) return null;
     String content = new String(bytes);
     infoParser = new Parser(content, true, display);
   } catch (FileNotFoundException e) {
     if (DEBUG) displayMessage("ERROR", "File " + filename + " not found.");
     return null;
   } catch (IOException e) {
     if (DEBUG) displayMessage("ERROR", "Read failed on file " + filename);
     return null;
   }
   return infoParser;
 }
  // Merge the availableChunks to build the original file
  void MergeChunks(File[] chunks) throws IOException {

    // Safety check
    if (chunks == null) {
      System.err.println("ERROR: No chunks to merge!");
      return;
    }

    FileOutputStream fos = new FileOutputStream("complete/" + filename);

    try {
      FileInputStream fis;
      byte[] fileBytes;
      int bytesRead;
      for (File f : chunks) {
        fis = new FileInputStream(f);
        fileBytes = new byte[(int) f.length()];
        bytesRead = fis.read(fileBytes, 0, (int) f.length());
        assert (bytesRead == fileBytes.length);
        assert (bytesRead == (int) f.length());
        fos.write(fileBytes);
        fos.flush();
        fileBytes = null;
        fis.close();
        fis = null;
      }
    } catch (Exception exception) {
      exception.printStackTrace();
    } finally {
      fos.close();
      fos = null;
    }
  }
Esempio n. 11
0
    private byte[] loadClassData(File f) throws ClassNotFoundException {
      FileInputStream stream = null;
      try {
        // System.out.println("loading: "+f.getPath());
        stream = new FileInputStream(f);

        try {
          byte[] b = new byte[stream.available()];
          stream.read(b);
          return b;
        } catch (IOException e) {
          throw new ClassNotFoundException();
        }
      } catch (FileNotFoundException e) {
        throw new ClassNotFoundException();
      } finally {
        if (stream != null) {
          try {
            stream.close();
          } catch (IOException e) {
            /* ignore */
          }
        }
      }
    }
Esempio n. 12
0
 /**
  * Load text string from a given file.
  *
  * @param fileStr the name of the file to be loaded.
  * @return A text string that is the content of the file. if the given file is not exist, then
  *     return null.
  */
 public static String getStringFromFile(String fileStr) throws Exception {
   String getStr = null;
   FileInputStream pspInputStream = new FileInputStream(fileStr);
   byte[] pspFileBuffer = new byte[pspInputStream.available()];
   pspInputStream.read(pspFileBuffer);
   pspInputStream.close();
   getStr = new String(pspFileBuffer);
   return (getStr);
 }
Esempio n. 13
0
  private void sendBytes(FileInputStream fis) throws Exception {
    // Construct a 1K buffer to hold bytes on their way to the socket.
    byte[] buffer = new byte[1024];
    int bytes = 0;

    while ((bytes = fis.read(buffer)) != -1) {
      sockManager.Escribir(buffer, bytes);
    }
  }
Esempio n. 14
0
 public static void copyFileToTheStandardOutput(String inputFileName) throws IOException {
   FileInputStream fis = new FileInputStream(inputFileName);
   int c;
   while ((c = fis.read()) != -1) {
     System.out.write(c); // won't work with big files as something
     // can write on the screen in the middle of the reading
   }
   fis.close();
 }
Esempio n. 15
0
 public static Charset guessEncoding(File f, int bufferLength, Charset defaultCharset)
     throws FileNotFoundException, IOException {
   FileInputStream fis = new FileInputStream(f);
   byte[] buffer = new byte[bufferLength];
   fis.read(buffer);
   fis.close();
   CharsetToolkit toolkit = new CharsetToolkit(buffer);
   toolkit.setDefaultCharset(defaultCharset);
   return toolkit.guessEncoding();
 }
Esempio n. 16
0
  public static void main(String[] args) {
    byte[] T, U, V;
    int[] A;
    int i, j, n, pidx;
    long start, finish;

    for (i = 0; i < args.length; ++i) {
      System.out.print(args[i] + ": ");
      try {
        /* Open a file for reading. */
        File f = new File(args[i]);
        FileInputStream s = new FileInputStream(f);

        n = (int) f.length();
        System.out.print(n + " bytes ... ");

        /* Allocate 5n bytes of memory. */
        T = new byte[n];
        U = new byte[n];
        V = new byte[n];
        A = new int[n];

        /* Read n bytes of data. */
        s.read(T);
        s.close();
        s = null;
        f = null;

        /* Construct the suffix array. */
        start = new Date().getTime();
        pidx = new sais().bwtransform(T, U, A, n);
        finish = new Date().getTime();
        System.out.println(((finish - start) / 1000.0) + " sec");

        System.out.print("unbwtcheck ... ");
        unbwt(U, V, A, n, pidx);
        for (j = 0; j < n; ++j) {
          if (T[j] != V[j]) {
            System.err.println("error " + j + ": " + T[j] + ", " + V[j]);
            return;
          }
        }
        System.err.println("Done.");

        T = null;
        U = null;
        V = null;
        A = null;
      } catch (IOException e) {
        e.printStackTrace();
      } catch (OutOfMemoryError e) {
        e.printStackTrace();
      }
    }
  }
Esempio n. 17
0
  /**
   * @param guid
   * @return
   * @throws IOException
   */
  public byte[] read(int guid) throws IOException {

    // read from file, return contents
    File file = new File(Integer.toString(guid));
    FileInputStream fis = null;
    fis = new FileInputStream(file);
    byte[] data = new byte[fis.available()];
    fis.read(data);

    return data;
  }
Esempio n. 18
0
    Decompressor(String inFile) throws Exception {
      lastString = "";
      finish = false;
      cursor = 0;
      output = new Vector();
      FileInputStream inStream = new FileInputStream(inFile);
      FileWriter fw = new FileWriter(inFile + "." + DECOMPRESSED_FILE_EXTENSION);
      oWriter = fw;

      while (true) {
        int indexHigh = (byte) inStream.read();
        if (indexHigh == -1) break;
        int indexMiddle = (byte) inStream.read();
        int indexLow = (byte) inStream.read();
        int index = indexHigh * BLOCK_SIZE * BLOCK_SIZE + indexMiddle * BLOCK_SIZE + indexLow;

        char c = (char) inStream.read();
        output.add(new Pair(index, c));
      }
    }
Esempio n. 19
0
  public static byte[] getBytes(File file) throws IOException {
    if (file == null || !file.exists()) {
      return null;
    }

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    FileInputStream in = new FileInputStream(file);

    int c = in.read();

    while (c != -1) {
      out.write(c);
      c = in.read();
    }

    in.close();
    out.close();

    return out.toByteArray();
  }
  private void sendData(FileInputStream data) throws SerialConnectionException {
    int tosend = 0;
    byte[] databuff = new byte[_chunkSize];

    _sent = 0;
    try {
      tosend = data.read(databuff);
      while (tosend != -1) {
        if (!_keepRunning) return;
        _os.write(databuff, 0, tosend);
        _savedStream.write(databuff, 0, tosend);
        _sent += tosend;
        // update GUI
        _results.updateBytesSent(_sent);
        tosend = data.read(databuff);
      }
    } catch (IOException e) {
      throw new SerialConnectionException("Error writing to i/o streams");
    }
  }
Esempio n. 21
0
 public Level1State read() {
   try {
     data = new byte[(int) file.length()];
     FileInputStream in = new FileInputStream(file);
     in.read(data);
     in.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
   Level1State l1s = Level1State.deserialize(data);
   return l1s;
 }
Esempio n. 22
0
 private void file_to_file(File in_file, File out_file) throws IOException, InterruptedException {
   FileInputStream in = in_file.inputStream();
   FileOutputStream out = out_file.outputStream();
   byte[] buffer = new byte[BUFFER_SIZE];
   int n_read;
   while ((n_read = in.read(buffer)) != -1) {
     checkForInterruption();
     out.write(buffer, 0, n_read);
   }
   in.close();
   out.close();
 }
  // post: refreshes the internal buffer with the next BYTE_SIZE bits
  private void nextByte() {
    this.currentByte = this.nextByte;
    if (this.currentByte != -1) {
      try {
        this.nextByte = input.read();
      } catch (IOException e) {
        throw new RuntimeException(e.toString());
      }
    }

    this.numBits = 0;
  }
  public static void main(String[] args) throws Exception {
    ByteArrayOutputStream bout;
    ByteArrayInputStream bin;
    ObjectOutputStream oout;
    ObjectInputStream oin;
    FileInputStream fin;
    File foof;
    CustomOutputStream cout;
    CustomInputStream cin;

    // test for backwards compatibility
    bout = new ByteArrayOutputStream();
    foof = new File(System.getProperty("test.src", "."), "Foo.ser");
    fin = new FileInputStream(foof);
    while (fin.available() > 0) bout.write(fin.read());
    byte[] buf1 = bout.toByteArray();

    bout = new ByteArrayOutputStream();
    oout = new ObjectOutputStream(bout);
    Foo foo = new Foo();
    oout.writeObject(foo);
    oout.flush();
    byte[] buf2 = bout.toByteArray();

    if (!Arrays.equals(buf1, buf2)) throw new Error("Incompatible stream format (write)");

    fin = new FileInputStream(foof);
    oin = new ObjectInputStream(fin);
    Foo foocopy = (Foo) oin.readObject();
    if (!foo.equals(foocopy)) throw new Error("Incompatible stream format (read)");

    // make sure write hook not called when old protocol in use
    bout = new ByteArrayOutputStream();
    cout = new CustomOutputStream(bout);
    cout.useProtocolVersion(PROTOCOL_VERSION_1);
    cout.writeObject(foo);
    if (cout.hookCalled) throw new Error("write descriptor hook should not be called");

    // write custom class descriptor representations
    bout = new ByteArrayOutputStream();
    cout = new CustomOutputStream(bout);
    cout.writeObject(foo);
    cout.flush();
    bin = new ByteArrayInputStream(bout.toByteArray());
    cin = new CustomInputStream(bin);
    foocopy = (Foo) cin.readObject();
    if (!cout.hookCalled) throw new Error("write descriptor hook never called");
    if (!cin.hookCalled) throw new Error("read descriptor hook never called");
    if (!foo.equals(foocopy)) throw new Error("serialization failed when hooks active");
  }
Esempio n. 25
0
  /** Procedure to set value for the code-swap strings */
  void getCodeSwapString() {
    File inputFile = new File(fileStr1);
    FileInputStream input = null;
    try {
      input = new FileInputStream(inputFile);
    } catch (FileNotFoundException fe) {
      System.err.println(fileStr1 + " not found. " + fe);
      // System.exit(-1);;
    }
    byte bt[] = new byte[(int) inputFile.length()];
    try {
      input.read(bt);
      textStr1 = new String(bt);
      input.close();
    } catch (IOException ie) {
      System.err.println("Can't read from the input stream " + ie);
      // System.exit(-1);;
    }

    inputFile = new File(fileStr2);
    try {
      input = new FileInputStream(inputFile);
    } catch (FileNotFoundException fe) {
      System.err.println(fileStr2 + " not found. " + fe);
      // System.exit(-1);;
    }
    try {
      bt = new byte[(int) inputFile.length()];
      input.read(bt);
      textStr2 = new String(bt);
      input.close();
    } catch (IOException ie) {
      System.err.println("Can't read from the input stream " + ie);
      // System.exit(-1);;
    }
  }
Esempio n. 26
0
    public char[] getCharacters() throws Exception {
      char[] ret = new char[(int) (inFile.length() + 1)];
      int retCursor = 0;
      FileInputStream from = new FileInputStream(inFile);

      while (true) {
        byte nextByte = (byte) from.read();
        if (nextByte == -1) break;

        char nextChar = (char) nextByte;
        ret[retCursor++] = nextChar;
      }

      ret[(int) (inFile.length())] = '\000';
      return ret;
    }
Esempio n. 27
0
  // Choose between wbxml or zip (the smallest one) to be used;
  // adds 3 additional bytes with metadata and set binary data for the record
  // returns length for the application settings + 3 bytes
  public int setBlockApplicationsForOneRecord(Record record) throws Exception {
    String key = record.key;
    // String generalPath = Const.WORKING_DIR + Const.PATH_SEP +
    //    key.replaceAll(":", "_");
    String generalPath = Const.WORKING_DIR + Const.PATH_SEP + Util.generateFileNameFromKey(key);

    File w = new File(generalPath + ".wbxml");
    if (!w.exists()) {
      throw new Exception("Error: The file " + generalPath + ".wbxml doesn't exist!");
    }

    FileInputStream in;
    boolean usedZip;
    // Choose between wbxml or zip (the smallest one) to be used in case if USE_ZIP
    // has not been set to false in function main().
    if (USE_ZIP) { // zip wbxml files
      File z = new File(generalPath + ".zip");
      if (!z.exists()) {
        throw new Exception("Error: The file " + generalPath + ".zip doesn't exist!");
      }
      FileInputStream inw = new FileInputStream(w);
      FileInputStream inz = new FileInputStream(z);
      usedZip = inz.available() < inw.available();
      in = (usedZip) ? inz : inw;
    } else { // do not zip wbxml files
      usedZip = false;
      in = new FileInputStream(w);
    }

    byte[] appWbxmlSettings = new byte[in.available()];
    in.read(appWbxmlSettings);
    in.close();

    // get 3 bytes that provide info: for data length (23 bits) and compressed flag (1 bit)
    // and write it into metaInfo
    BlockTable metaInfo =
        new BlockTable((Const.APP_BLOCK_LENGTH + Const.APP_COMPRESSWD_FLAG) / 8); // 3 bytes
    int appBlockSettingsLength = metaInfo.data.length + appWbxmlSettings.length;
    int compressFlag = (usedZip) ? 1 : 0;
    Util.addBitsToTable(metaInfo, appBlockSettingsLength, Const.APP_BLOCK_LENGTH);
    Util.addBitsToTable(metaInfo, compressFlag, Const.APP_COMPRESSWD_FLAG);
    record.setBlockApplicationSettings(metaInfo.data, appWbxmlSettings);

    Validator.validateAppBlockSettingsLength(appBlockSettingsLength, generalPath);

    return appBlockSettingsLength;
  }
Esempio n. 28
0
  public Class loadNewClass(String javaFile, String packageName) {
    Class myClass = null;

    String className = javaFile.replace(".java", ".class");

    File inpFile = new File(className);
    int idx = className.lastIndexOf(File.separatorChar);
    String javaName = className.substring(idx + 1, className.indexOf("."));
    int size = (int) inpFile.length();
    byte[] ba = new byte[size];
    try {
      FileInputStream fis = new FileInputStream(className);

      // read the entry
      int bytes_read = 0;
      while (bytes_read != size) {
        int r = fis.read(ba, bytes_read, size - bytes_read);
        if (r < 0) break;
        bytes_read += r;
      }
      if (bytes_read != size) throw new IOException("cannot read entry");
    } catch (FileNotFoundException fnfExc) {
      System.out.println("File : " + className + " not found");
      fnfExc.printStackTrace();
    } catch (IOException ioExc) {
      System.out.println("IO Exception in JavaCompile trying to read class: ");
      ioExc.printStackTrace();
    }

    try {
      String packageAppendedFileName = "";
      if (packageName.isEmpty()) packageAppendedFileName = javaName;
      else packageAppendedFileName = packageName + "." + javaName;
      packageAppendedFileName.replace(File.separatorChar, '.');
      myClass = defineClass(packageAppendedFileName, ba, 0, size);
      // SOS-StergAutoCompletionScalaSci.upDateAutoCompletion(myClass);
      String userClassName = myClass.getName();
      JOptionPane.showMessageDialog(null, "Class " + userClassName + " loaded successfully !");
    } catch (ClassFormatError exc) {
      System.out.println("error defining class " + inpFile);
      exc.printStackTrace();
    } catch (Exception ex) {
      System.out.println("some error defining class " + inpFile);
      ex.printStackTrace();
    }
    return myClass;
  }
Esempio n. 29
0
  protected byte[] getClassData(String directory, String name) {
    String classFile = directory + "/" + name.replace('.', '/') + ".class";

    int classSize = (int) new File(classFile).length();
    byte[] buf = new byte[classSize];

    try {
      FileInputStream filein = new FileInputStream(classFile);
      classSize = filein.read(buf);
      filein.close();
    } catch (FileNotFoundException e) {
      return null;
    } catch (IOException e) {
      return null;
    }
    return buf;
  }
Esempio n. 30
0
 /**
  * Copy source file to destination file.
  *
  * @throws SecurityException
  * @throws IOException
  */
 public static void copyFile(File destfile, File srcfile) throws IOException {
   byte[] bytearr = new byte[512];
   int len = 0;
   FileInputStream input = new FileInputStream(srcfile);
   File destDir = destfile.getParentFile();
   destDir.mkdirs();
   FileOutputStream output = new FileOutputStream(destfile);
   try {
     while ((len = input.read(bytearr)) != -1) {
       output.write(bytearr, 0, len);
     }
   } catch (FileNotFoundException exc) {
   } catch (SecurityException exc) {
   } finally {
     input.close();
     output.close();
   }
 }