/**
* AUTOHIT 2003
* Copyright Erich P Gatejen (c) 1989,1997,2003,2004
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Additional license information can be found in the documentation.
* @author Erich P Gatejen
*/
package autohit.common;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import org.apache.commons.collections.ExtendedProperties;
/**
* A bunch of utils
*
* @author Erich P. Gatejen
* @version 1.0
* Version History
* EPG - Rewrite - 9Apr03
*
*/
public class Utils {
// internal state values
private final static int STATE_FRESH = 0;
private final static int STATE_FRONT = 1;
private final static int STATE_READ = 2;
private final static int STATE_TAIL = 3;
// Again. I can't beleive I have to do this. This MAY break in future JDKs.
// It seems that BufferedReader.read() does NOT return -1 for an empty string; it
// returns the freaking 2scompliment of -1.
// (2003-May: This may work now. I'm too lazy to check it.)
private final static int MORONIC_TOP_VALUE = 65534;
/**
* Converts dot namespace to a path
* @param header prefix for the path
* @param dot path in dot notation
* @return a converted path
*/
public static String dot2path(String header, String dot) {
return header
+ AutohitProperties.literal_PATH_SEPERATOR
+ dot.replace(
AutohitProperties.literal_NAME_SEPERATOR,
AutohitProperties.literal_PATH_SEPERATOR);
}
/**
* Make a file reference. If the file already exists, kill it.
* If the path doesn't exist, make it. It'll throw an exception if
* it fails.
* @param name path name
* @return file object
* @throws Exception
*/
public static File makeFile(String name) throws Exception {
File dir;
String dirpath;
int last;
// construct the path
File target = new File(name);
if (target.exists()) {
target.delete();
} else {
// futz with the directory and make it is neccessary
last = name.lastIndexOf(AutohitProperties.literal_PATH_SEPERATOR);
if (last > 1) {
dirpath = name.substring(0, last);
dir = new File(dirpath);
if (!dir.exists()) {
dir.mkdirs();
}
}
}
return target;
}
/**
* Test and get property. Return null if not found or something went wrong.
* Traps all exceptions
* @param key key for the property
* @param props the property set
* @return the property object
*/
public static Object testGetProperty(
String key,
ExtendedProperties props) {
Object thing = null;
try {
thing = props.getProperty(key);
} catch (Exception e) {
thing = null;
}
return thing;
}
/**
* Test and get property for truth. If will return true if the property
* containts 'true', otherwise it will return false;
* Traps all exceptions
* @param key key for the property
* @param props the property set
* @return true if the proprerty is 'true', otherwise false.
*/
public static boolean testGetPropertyTruth(
String key,
ExtendedProperties props) {
boolean thing = false;
String thang;
try {
thang = (String)props.getProperty(key);
thing = thang.equals(Constants.TRUE);
} catch (Exception e) {
}
return thing;
}
/**
* Copy files. I can't believe I have to write this. It will always
* overwrite an existing file.
* @param source source file path
* @param dest destination file path
* @return string containing errors or messages
*/
public static String copy(String source, String dest) {
String overwrite = " ";
BufferedOutputStream bos = null;
try {
File destf = new File(dest);
if (destf.exists()) {
destf.delete();
overwrite = " [overwrite] ";
}
byte[] buf = new byte[1024];
int sbuf;
BufferedInputStream bis =
new BufferedInputStream(new FileInputStream(source));
bos = new BufferedOutputStream(new FileOutputStream(dest));
sbuf = bis.read(buf, 0, 1024);
while (sbuf > 0) {
bos.write(buf, 0, sbuf);
sbuf = bis.read(buf, 0, 1024);
}
} catch (Exception e) {
}
try {
bos.close();
} catch (Exception e) {
return "Copy failed for=" + source + Constants.CRUDE_SEPERATOR;
}
return "Copied file=" + source + overwrite + Constants.CRUDE_SEPERATOR;
}
/**
* Merge a file with properties. It will overwrite an existing file.
* This is not exactly FAST.
* @param source source file
* @param dest destination file
* @param props properties that are candidates for substitution
* @return string containing errors or messages
*/
public static String merge(
String source,
String dest,
ExtendedProperties props) {
int state = STATE_FRESH;
BufferedReader inBR = null;
BufferedWriter outT = null;
int workingC;
StringBuffer cBuf = null;
String theVar = null;
String ts = null;
StringBuffer messages = new StringBuffer();
String overwrite = " ";
// Read and fix
try {
// Clear an existing file
File destf = new File(dest);
if (destf.exists()) {
destf.delete();
overwrite = " [overwrite] ";
}
inBR = new BufferedReader(new FileReader(source));
outT = new BufferedWriter(new FileWriter(dest));
// start the engine
workingC = inBR.read();
while ((workingC >= 0)
&& (workingC
< MORONIC_TOP_VALUE)) {
switch (state) {
case STATE_FRESH :
if (workingC == Constants.CONFIG_OPEN)
state = STATE_FRONT;
else
outT.write(workingC);
break;
case STATE_FRONT :
if (workingC == Constants.CONFIG_OPEN) {
state = STATE_READ;
cBuf = new StringBuffer();
} else {
state = STATE_FRESH;
outT.write(Constants.CONFIG_OPEN);
outT.write(workingC);
}
break;
case STATE_READ :
if (workingC == Constants.CONFIG_CLOSE) {
state = STATE_TAIL;
} else {
cBuf.append((char) workingC);
}
break;
case STATE_TAIL :
if (workingC == Constants.CONFIG_CLOSE) {
state = STATE_FRESH;
theVar = cBuf.toString();
if (props.containsKey(theVar)) {
ts = (String) props.get(theVar);
outT.write(ts, 0, ts.length());
} else {
outT.write(Constants.CONFIG_BLANK);
}
} else {
outT.write(Constants.CONFIG_CLOSE);
outT.write(workingC);
}
break;
} // end case
workingC = inBR.read();
}
} catch (Exception e) {
// Might just be EOF
//System.out.println(e);
} finally {
try {
inBR.close();
outT.close();
if (state != STATE_FRESH) {
messages.append(
"Bad File. Incomplete escape <<>> in file="
+ source + Constants.CRUDE_SEPERATOR);
messages.append("......... Destination file might be corrupt. file=" + dest + Constants.CRUDE_SEPERATOR);
}
messages.append("Merged file to=" + dest + overwrite + Constants.CRUDE_SEPERATOR);
} catch (Exception e) {
messages.append("Catastrophic error merging" + source + Constants.CRUDE_SEPERATOR);
messages.append("......... Destination file might be corrupt. file=" + dest + Constants.CRUDE_SEPERATOR);
}
}
return messages.toString();
}
/**
* Copy entire directories. I can't believe I have to write this.
* @param source source is the source directory, without a training slash
* @param dest destination is the destination directory, without a training slash
* @param wipe destructive copy. If true, it will destroy destination directories before
* copying the files. The files themselves are always overwritten.
* @return string containing errors or messages
*/
public static String copyDir(String source, String dest, boolean wipe) {
String[] directory;
String destinationfile = "";
String sourcefile;
File fsource = new File(source);
File fdest = new File(dest);
int size;
StringBuffer messages = new StringBuffer();
try {
// get the source directory list
directory = fsource.list();
// create the destination directory. If it already exists, wipe it.
if (fdest.exists()) {
if (wipe == true) {
messages.append(Utils.wipeDir(dest));
fdest.mkdirs();
messages.append(
"Make directory=" + dest + Constants.CRUDE_SEPERATOR);
}
} else {
fdest.mkdirs();
messages.append(
"Make directory=" + dest + Constants.CRUDE_SEPERATOR);
}
// rove the directory list
for (int i = 0; i < directory.length; i++) {
try {
destinationfile = dest + '/' + directory[i];
sourcefile = source + '/' + directory[i];
fsource = new File(sourcefile);
if (fsource.isDirectory()) {
messages.append(
"Is directory="
+ sourcefile
+ Constants.CRUDE_SEPERATOR);
messages.append(
Utils.copyDir(sourcefile, destinationfile, wipe));
} else {
messages.append(
Utils.copy(sourcefile, destinationfile));
}
} catch (Exception e) {
messages.append(
"Error on="
+ destinationfile
+ Constants.CRUDE_SEPERATOR);
}
}
messages.append(
"Done with directory= " + source + Constants.CRUDE_SEPERATOR);
} catch (Exception e) {
messages.append(
"Serious error on="
+ dest
+ " error="
+ e.getMessage()
+ Constants.CRUDE_SEPERATOR);
}
return messages.toString();
}
/**
* Wipe a directory and everything in it
* @param dest path to the directory
* @return string containing errors or messages
*/
public static String wipeDir(String dest) {
String[] directory;
File fsource = new File(dest);
StringBuffer messages = new StringBuffer();
String newdest;
File newf;
try {
// get the source directory list
directory = fsource.list();
// rove the directory list
for (int i = 0; i < directory.length; i++) {
try {
newdest = dest + '/' + directory[i];
newf = new File(newdest);
if (newf.isDirectory()) {
messages.append(
"Wipe directory="
+ newdest
+ Constants.CRUDE_SEPERATOR);
messages.append(Utils.wipeDir(newdest));
} else {
newf.delete();
}
} catch (Exception e) {
messages.append(
"Error on wipe=" + dest + Constants.CRUDE_SEPERATOR);
}
}
fsource.delete();
messages.append(
"Done wipe of directory= " + dest + Constants.CRUDE_SEPERATOR);
} catch (Exception e) {
messages.append(
"Serious error on wipe of= "
+ dest
+ " error="
+ e.getMessage()
+ Constants.CRUDE_SEPERATOR);
}
return messages.toString();
}
/**
* Read a file into a String.
* @param f File to read
* @return string if successful or otherwise null
*/
public static String loadFile2String(File f) {
StringBuffer buffer = new StringBuffer();
try {
char[] buf = new char[1024];
int sbuf;
BufferedReader bis
= new BufferedReader(new FileReader(f));
sbuf = bis.read(buf, 0, 1024);
while (sbuf > 0) {
buffer.append(buf, 0, sbuf);
sbuf = bis.read(buf, 0, 1024);
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
return buffer.toString();
}
/**
* Get a packed, big-endian integer. The array better have 4 bytes or you'll get an exception
* @param buf arracy of bytes
* @return the integer
*/
public static int packInteger(byte[] buf) {
return ((buf[3] & 0xFF) << 0) +
((buf[2] & 0xFF) << 8) +
((buf[1] & 0xFF) << 16) +
((buf[0] & 0xFF) << 24);
}
/**
* Unpack an integer into an array--big-endian. The array better have 4 bytes or you'll get an exception
* @param buf array of bytes. better be at least 4 bytes
* @param offset offset into the array to start the unpack
* @param value the integer to unpack
*/
public static void unpackInteger(byte[] buf, int offset, int value) {
buf[offset + 3] = (byte) (value >>> 0);
buf[offset + 2] = (byte) (value >>> 8);
buf[offset + 1] = (byte) (value >>> 16);
buf[offset + 0] = (byte) (value >>> 24);
}
// Total kludge. don't use
public static String norfIt(int value) {
if (value < 10) {
return new String ("0" + value);
} else if (value < 100) {
return Integer.toString(value);
} else if (value < 385) {
StringBuffer zonk = new StringBuffer();
zonk.append((char)value / 65);
zonk.append((char)value % 65);
return zonk.toString();
} else {
return "xx";
}
}
}