Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.duelengine.duel.utils;
  
  import java.io.File;
 import java.util.List;
 import java.util.Set;
 
 
 public class FileUtil {
 
 	public enum HashEncoding {
 		DEFAULT,
 		HEX,
 		BASE64
 	}
 
 	private static final Logger log = LoggerFactory.getLogger(FileUtil.class);
 	private static final int DEFAULT_BUFFER_SIZE = 4096;
 	private static final int SHA1_HEX_LENGTH = 40;
 	private static final int SHA1_BASE64_LENGTH = 27;
 	private static final int MD5_HEX_LENGTH = 32;
 	private static final int MD5_BASE64_LENGTH = 22;
 	public static final String SHA1 = "SHA-1";
 	public static final String MD5 = "MD5";
 
 	public static File getCanonicalFile(String path) {
 		if (path == null) {
 			throw new NullPointerException("path");
 		}
 
 		return getCanonicalFile(new File(path));
 	}
 
 	public static File getCanonicalFile(File file) {
 		if (file == null) {
 			throw new NullPointerException("file");
 		}
 
 		try {
 			return file.getCanonicalFile();
 
 		} catch (IOException e) {
 			return file.getAbsoluteFile();
 		}
 	}
 
 	public static void prepSavePath(File file) {
 		if (file == null) {
 			throw new NullPointerException("file");
 		}
 
 		if (!file.getParentFile().exists()) {
 			file.getParentFile().mkdirs();
 		}
 	}
 
 	public static void copy(File sourceFile targetboolean overwrite)
 			throws IOException {
 
 		copy(sourcetargetoverwritenull);
 	}
 
 	public static void copy(File sourceFile targetboolean overwritebyte[] buffer)
 			throws IOException {
 
 		if (target == null) {
 			throw new NullPointerException("target");
 		}
 		if (source == null) {
 			throw new NullPointerException("source");
 		}
 		if (!source.exists()) {
 			throw new FileNotFoundException(source.toString());
 		}
 		if (!source.isFile()) {
 			return;
 		}
 		if (!overwrite && target.exists()) {
 			return;
 		}
 		if (buffer == null) {
 			buffer = new byte[];
 		}
 
 		prepSavePath(target);
 		
 		FileInputStream sourceStream = null;
		FileOutputStream targetStream = null;
		try {
			sourceStream = new FileInputStream(source);
			targetStream = new FileOutputStream(target);
			int count;
			while ((count = sourceStream.read(buffer)) > 0) {
				targetStream.write(buffer, 0, count);
			}
finally {
			if (targetStream != null) {
				try {
					targetStream.close();
catch (IOException e) {}
			}
			if (sourceStream != null) {
				try {
					sourceStream.close();
catch (IOException e) {}
			}
		}
	}
	public static List<FilefindFiles(File rootString... extensions) {
		if (extensions == null || extensions.length < 1) {
			// no filter, returns all files
			return findFiles(root, (Set<String>)null);
		}
		Set<StringextSet = new HashSet<String>(extensions.length);
		for (String ext : extensions) {
			extSet.add(ext);
		}
		return findFiles(rootextSet);
	}
	public static List<FilefindFiles(File rootSet<Stringextensions) {
		// no filter, returns all files
		boolean noFilter = (extensions == null || extensions.size() < 1);
		List<Filefiles = new ArrayList<File>();
		Queue<Filedirs = new LinkedList<File>();
		dirs.add(root);
		while (!dirs.isEmpty()) {
			File file = dirs.remove();
			if (file.isDirectory()) {
				dirs.addAll(Arrays.asList(file.listFiles()));
				continue;
			}
			String ext = getExtension(file.getName());
			if (noFilter || extensions.contains(ext)) {
				files.add(file);
else {
				.info("Skipping: "+file.getName());
			}
		}
		if (files.size() < 1) {
			.warn("No input files found.");
		}
		return files;
	}
	public static String getRelativePath(File rootFile child) {
		String prefix;
		try {
			prefix = root.getCanonicalPath();
catch (IOException e) {
			prefix = root.getAbsolutePath();
		}
		String path;
		try {
			path = child.getCanonicalPath();
catch (IOException e) {
			path = child.getAbsolutePath();
		}
		if (path.indexOf(prefix) != 0) {
			return child.getPath();
		}
		if (prefix.length() == path.length()) {
			return "";
		}
		int start = prefix.length();
		if (path.charAt(start) == '/') {
			start++;
		}
		return path.substring(start);
	}
	public static String getExtension(File file) {
		if (file == null) {
			return "";
		}
		return getExtension(file.getName());
	}
	public static String getExtension(String name) {
		int dot = name.lastIndexOf('.');
		if (dot < 0) {
			return "";
		}
		return name.substring(dot).toLowerCase();
	}
	public static File replaceExtension(File fileString ext) {
		if (file == null) {
			throw new NullPointerException("file");
		}
		if (ext == null || ext.isEmpty()) {
			throw new NullPointerException("ext");
		}
		String name = file.getName();
		int dot = name.lastIndexOf('.');
		String newName = (dot < 0) ? name : name.substring(0, dot);
		if (ext.indexOf('.') != 0) {
			ext = '.'+ext;
		}
		newName += ext;
		return new File(file.getParentFile(), newName);
	}
	public static String calcSHA1(File file)
		return calcHash(file.null);
	}
	public static String calcMD5(File file)
		return calcHash(file.null);
	}
	public static String calcHash(File fileString algorithmHashEncoding encoding)
		return calcHash(filealgorithmencodingnull);
	}
	public static String calcHash(File fileString algorithmHashEncoding encodingbyte[] buffer)
		if (file == null) {
			throw new NullPointerException("file");
		}
		if (!file.exists()) {
			throw new FileNotFoundException(file.toString());
		}
		if (buffer == null) {
			buffer = new byte[];
		}
		FileInputStream stream = null;
		try {
			MessageDigest hash = MessageDigest.getInstance(algorithm);
			stream = new FileInputStream(file);
			int count;
			while ((count = stream.read(buffer)) > 0) {
				hash.update(buffer, 0, count);
			}
			byte[] digest = hash.digest();
			switch (encoding) {
				case :
					return encodeBytesBase64(digest);
				default:
				case :
					return encodeBytesHex(digest);
			}
catch (Exception ex) {
			.error(algorithm+" Error"ex);
			return null;
finally {
			if (stream != null) {
				try {
					stream.close();
catch (IOException e) {}
			}
		}
	}
	public static boolean isSHA1(String signature) {
		// validate signature length and content
		if (signature == null) {
			return false;
		}
		switch (signature.length()) {
				return isHex(signature);
				return Base64.isBase64(signature);
			default:
				return false;
		}
	}
	public static boolean isMD5(String signature) {
		// validate signature length and content
		if (signature == null) {
			return false;
		}
		switch (signature.length()) {
				return isHex(signature);
				return Base64.isBase64(signature);
			default:
				return false;
		}
	}
	private static boolean isHex(String signature) {
		if (signature == null || signature.isEmpty()) {
			return false;
		}
		for (int i=signature.length()-1; i>=0; i--) {
			char ch = signature.charAt(i);
			if ((ch >= '0' && ch <= '9') ||
				(ch >= 'a' && ch <= 'f') ||
				(ch >= 'A' && ch <= 'F'))
			{
				continue;
			}
			return false;
		}
		return true;
	}
	private static String encodeBytesBase64(byte[] digest) {
		return Base64.encodeBase64URLSafeString(digest);
	}
	private static String encodeBytesHex(byte[] digest) {
		for (int i=0; i<digest.lengthi++) {
			int digit = 0xFF & digest[i];
			if (digit < 0x10) {
				hex.append('0');
			}
			hex.append(Integer.toHexString(digit));
		}
		return hex.toString();
	}
New to GrepCode? Check out our FAQ X