source/mir/misc/FileUtil.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30 package mir.misc;
  31
  32 import java.io.BufferedInputStream;
  33 import java.io.BufferedOutputStream;
  34 import java.io.BufferedWriter;
  35 import java.io.File;
  36 import java.io.FileInputStream;
  37 import java.io.FileOutputStream;
  38 import java.io.IOException;
  39 import java.io.InputStream;
  40 import java.io.OutputStreamWriter;
  41 import java.io.Reader;
  42 /**
  43  * Hilfsklasse zum Mergen von Template und Daten
  44  */
  45 public final class FileUtil {
  46   /**
  47    * Privater Construktor to avoid accidental instantiation
  48    */
  49   private FileUtil() {
  50   }
  51
  52   public static File getFile(String filename) throws IOException {
  53
  54     try {
  55       File f = null;
  56       f = new File(filename);
  57       File dir = new File(f.getParent());
  58       dir.mkdirs();
  59
  60       return f;
  61     }
  62     catch (Exception e) {
  63       throw new IOException(e.toString());
  64     }
  65
  66   }
  67
  68   public static long write(File f, InputStream in) throws IOException {
  69
  70     long size = 0;
  71
  72     if (in != null) {
  73       try {
  74         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(f),8192);
  75
  76         // TODO get size with in.available()
  77         int read;
  78         byte[] buf = new byte[8 * 1024];
  79         while ( (read = in.read(buf)) != -1) {
  80           out.write(buf, 0, read);
  81           size += read;
  82         }
  83
  84         in.close();
  85         out.close();
  86       }
  87       catch (IOException e) {
  88         throw new IOException(e.toString());
  89       }
  90     }
  91     return size;
  92   }
  93
  94   public static long write(String filename, InputStream in) throws IOException {
  95
  96     long size = 0;
  97
  98     if (in != null) {
  99       try {
 100         File f = getFile(filename);
 101         size = write(f, in);
 102       }
 103       catch (IOException e) {
 104         throw new IOException(e.toString());
 105       }
 106     }
 107     return size;
 108   }
 109
 110   public static long write(String filename, Reader in, String encoding) throws IOException {
 111
 112     long size = 0;
 113
 114     if (in != null) {
 115       try {
 116         File f = getFile(filename);
 117         FileOutputStream fOut = new FileOutputStream(f);
 118         BufferedWriter out = new BufferedWriter(new OutputStreamWriter(fOut, encoding),8192);
 119         int read;
 120         char[] cbuf = new char[8 * 1024];
 121         while ( (read = in.read(cbuf)) != -1) {
 122           out.write(cbuf, 0, read);
 123           size += read;
 124         }
 125
 126         out.close();
 127         in.close();
 128       }
 129       catch (IOException e) {
 130         throw new IOException(e.toString());
 131       }
 132     }
 133     return size;
 134   }
 135
 136   public static boolean read(String filename, byte out[]) throws IOException {
 137
 138     File f = null;
 139     f = new File(filename);
 140
 141     if (f.exists()) {
 142       try {
 143         if (out.length != f.length())
 144           return false;
 145         BufferedInputStream inStream;
 146         inStream = new BufferedInputStream(new FileInputStream(f),8192);
 147         inStream.read(out);
 148         inStream.close();
 149       }
 150       catch (IOException e) {
 151         throw new IOException(e.toString());
 152       }
 153     }
 154     else {
 155       return false;
 156     }
 157     return true;
 158   }
 159
 160   public static long getSize(String filename) {
 161     File f = null;
 162     f = new File(filename);
 163     long l = 0;
 164
 165     if (f.exists()) {
 166       return f.length();
 167     }
 168     else {
 169       return -1;
 170     }
 171   }
 172
 173 }