/**

static public int countLines(String what) {

int count = 1;

for (char c : what.toCharArray()) {

if (c == '\n') count++;

}

return count;

}

/**

static public byte[] loadBytesRaw(File file) throws IOException {

int size = (int) file.length();

FileInputStream input = new FileInputStream(file);

byte buffer[] = new byte[size];

int offset = 0;

int bytesRead;

while ((bytesRead = input.read(buffer, offset, size-offset)) != -1) {

offset += bytesRead;

if (bytesRead == 0) break;

}

input.close(); // weren't properly being closed

input = null;

return buffer;

}

/**

static public StringDict readSettings(File inputFile) {

if (!inputFile.exists()) {

if (Base.DEBUG) System.err.println(inputFile + " does not exist.");

return null;

}

String lines[] = PApplet.loadStrings(inputFile);

if (lines == null) {

System.err.println("Could not read " + inputFile);

return null;

}

return readSettings(inputFile.toString(), lines);

}

/**

static public StringDict readSettings(String filename, String[] lines) {

StringDict settings = new StringDict();

for (String line : lines) {

// Remove comments

int commentMarker = line.indexOf('#');

if (commentMarker != -1) {

line = line.substring(0, commentMarker);

}

// Remove extra whitespace

line = line.trim();

if (line.length() != 0) {

int equals = line.indexOf('=');

if (equals == -1) {

if (filename != null) {

System.err.println("Ignoring illegal line in " + filename);

System.err.println(" " + line);

}

} else {

String attr = line.substring(0, equals).trim();

String valu = line.substring(equals + 1).trim();

settings.set(attr, valu);

}

}

}

return settings;

}

static public void copyFile(File sourceFile,

File targetFile) throws IOException {

BufferedInputStream from =

new BufferedInputStream(new FileInputStream(sourceFile));

BufferedOutputStream to =

new BufferedOutputStream(new FileOutputStream(targetFile));

byte[] buffer = new byte[16 * 1024];

int bytesRead;

while ((bytesRead = from.read(buffer)) != -1) {

to.write(buffer, 0, bytesRead);

}

from.close();

from = null;

to.flush();

to.close();

to = null;

targetFile.setLastModified(sourceFile.lastModified());

targetFile.setExecutable(sourceFile.canExecute());

}

/**

static public String loadFile(File file) throws IOException {

String[] contents = PApplet.loadStrings(file);

if (contents == null) return null;

return PApplet.join(contents, "\n");

}

/**

static public void saveFile(String str, File file) throws IOException {

if (Platform.isWindows()) {

String[] lines = str.split("\\r?\\n");

str = PApplet.join(lines, "\r\n");

}

File temp = File.createTempFile(file.getName(), null, file.getParentFile());

try {

// fix from cjwant to prevent symlinks from being destroyed.

File canon = file.getCanonicalFile();

// assign the var as second step since previous line may throw exception

file = canon;

} catch (IOException e) {

throw new IOException("Could not resolve canonical representation of " +

file.getAbsolutePath());

}

// Can't use saveStrings() here b/c Windows will add a ^M to the file

PrintWriter writer = PApplet.createWriter(temp);

writer.print(str);

boolean error = writer.checkError(); // calls flush()

writer.close(); // attempt to close regardless

if (error) {

throw new IOException("Error while trying to save " + file);

}

// remove the old file before renaming the temp file

if (file.exists()) {

boolean result = file.delete();

if (!result) {

throw new IOException("Could not remove old version of " +

file.getAbsolutePath());

}

}

boolean result = temp.renameTo(file);

if (!result) {

throw new IOException("Could not replace " + file.getAbsolutePath() +

" with " + temp.getAbsolutePath());

}

}

/**

static public File createTempFolder(String prefix, String suffix,

File directory) throws IOException {

int fillChars = 3 - prefix.length();

for (int i = 0; i < fillChars; i++) {

prefix += '_';

}

File folder = File.createTempFile(prefix, suffix, directory);

// Now delete that file and create a folder in its place

folder.delete();

folder.mkdirs();

// And send the folder back to your friends

return folder;

}

/**

static public void copyDir(File sourceDir,

File targetDir) throws IOException {

if (sourceDir.equals(targetDir)) {

final String urDum = "source and target directories are identical";

throw new IllegalArgumentException(urDum);

}

targetDir.mkdirs();

String files[] = sourceDir.list();

for (int i = 0; i < files.length; i++) {

// Ignore dot files (.DS_Store), dot folders (.svn) while copying

if (files[i].charAt(0) == '.') continue;

//if (files[i].equals(".") || files[i].equals("..")) continue;

File source = new File(sourceDir, files[i]);

File target = new File(targetDir, files[i]);

if (source.isDirectory()) {

//target.mkdirs();

copyDir(source, target);

target.setLastModified(source.lastModified());

} else {

copyFile(source, target);

}

}

}

static public void copyDirNative(File sourceDir,

File targetDir) throws IOException {

Process process = null;

if (Platform.isMacOS() || Platform.isLinux()) {

process = Runtime.getRuntime().exec(new String[] {

"cp", "-a", sourceDir.getAbsolutePath(), targetDir.getAbsolutePath()

});

} else {

// TODO implement version that uses XCOPY here on Windows

throw new RuntimeException("Not yet implemented on Windows");

}

try {

int result = process.waitFor();

if (result != 0) {

throw new IOException("Error while copying (result " + result + ")");

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

/**

static public boolean removeDir(File dir) {

return removeDir(dir, true);

}

/**

static public boolean removeDir(File dir, boolean printErrorMessages) {

if (!dir.exists()) return true;

boolean result = true;

if (!Files.isSymbolicLink(dir.toPath())) {

File[] files = dir.listFiles();

if (files != null) {

for (File child : files) {

if (child.isFile()) {

boolean deleted = child.delete();

if (!deleted && printErrorMessages) {

System.err.println("Could not delete " + child.getAbsolutePath());

}

result &= deleted;

} else if (child.isDirectory()) {

result &= removeDir(child, printErrorMessages);

}

}

}

}

boolean deleted = dir.delete();

if (!deleted && printErrorMessages) {

System.err.println("Could not delete " + dir.getAbsolutePath());

}

result &= deleted;

return result;

}

/**

static public long calcSize(File file) {

return file.isFile() ? file.length() : Util.calcFolderSize(file);

}

/**

static public long calcFolderSize(File folder) {

int size = 0;

String files[] = folder.list();

// null if folder doesn't exist, happens when deleting sketch

if (files == null) return -1;

for (int i = 0; i < files.length; i++) {

if (files[i].equals(".") ||

files[i].equals("..") ||

files[i].equals(".DS_Store")) continue;

File fella = new File(folder, files[i]);

if (fella.isDirectory()) {

size += calcFolderSize(fella);

} else {

size += (int) fella.length();

}

}

return size;

}

/**

static public String[] listFiles(File folder, boolean relative) {

return listFiles(folder, relative, null);

}

static public String[] listFiles(File folder, boolean relative,

String extension) {

if (extension != null) {

if (!extension.startsWith(".")) {

extension = "." + extension;

}

}

StringList list = new StringList();

listFilesImpl(folder, relative, extension, list);

if (relative) {

String[] outgoing = new String[list.size()];

// remove the slash (or backslash) as well

int prefixLength = folder.getAbsolutePath().length() + 1;

for (int i = 0; i < outgoing.length; i++) {

outgoing[i] = list.get(i).substring(prefixLength);

}

return outgoing;

}

return list.array();

}

static void listFilesImpl(File folder, boolean relative,

String extension, StringList list) {

File[] items = folder.listFiles();

if (items != null) {

for (File item : items) {

String name = item.getName();

if (name.charAt(0) != '.') {

if (item.isDirectory()) {

listFilesImpl(item, relative, extension, list);

} else { // a file

if (extension == null || name.endsWith(extension)) {

list.append(item.getAbsolutePath());

}

}

}

}

}

}

/**

static public File[] listJarFiles(File folder) {

return folder.listFiles(new FilenameFilter() {

public boolean accept(File dir, String name) {

return (!name.startsWith(".") &&

(name.toLowerCase().endsWith(".jar") ||

name.toLowerCase().endsWith(".zip")));

}

});

}

/////////////////////////////////////////////////////////////////////////////

/**

static public String contentsToClassPath(File folder) {

if (folder == null) return "";

StringBuilder sb = new StringBuilder();

String sep = System.getProperty("path.separator");

try {

String path = folder.getCanonicalPath();

// When getting the name of this folder, make sure it has a slash

// after it, so that the names of sub-items can be added.

if (!path.endsWith(File.separator)) {

path += File.separator;

}

String list[] = folder.list();

for (int i = 0; i < list.length; i++) {

// Skip . and ._ files. Prior to 0125p3, .jar files that had

// OS X AppleDouble files associated would cause trouble.

if (list[i].startsWith(".")) continue;

if (list[i].toLowerCase().endsWith(".jar") ||

list[i].toLowerCase().endsWith(".zip")) {

sb.append(sep);

sb.append(path);

sb.append(list[i]);

}

}

} catch (IOException e) {

e.printStackTrace(); // this would be odd

}

return sb.toString();

}

/**

static public StringList packageListFromClassPath(String path) {

StringList list = new StringList();

String pieces[] =

PApplet.split(path, File.pathSeparatorChar);

for (int i = 0; i < pieces.length; i++) {

//System.out.println("checking piece '" + pieces[i] + "'");

if (pieces[i].length() == 0) continue;

if (pieces[i].toLowerCase().endsWith(".jar") ||

pieces[i].toLowerCase().endsWith(".zip")) {

//System.out.println("checking " + pieces[i]);

packageListFromZip(pieces[i], list);

} else { // it's another type of file or directory

File dir = new File(pieces[i]);

if (dir.exists() && dir.isDirectory()) {

packageListFromFolder(dir, null, list);

//importCount = magicImportsRecursive(dir, null,

// map);

//imports, importCount);

}

}

}

StringList outgoing = new StringList(list.size());

for (String item : list) {

outgoing.append(item.replace('/', '.'));

}

return outgoing;

}

static private void packageListFromZip(String filename, StringList list) {

try {

ZipFile file = new ZipFile(filename);

Enumeration<?> entries = file.entries();

while (entries.hasMoreElements()) {

ZipEntry entry = (ZipEntry) entries.nextElement();

if (!entry.isDirectory()) {

String name = entry.getName();

if (name.endsWith(".class")) {

int slash = name.lastIndexOf('/');

if (slash == -1) continue;

String pname = name.substring(0, slash);

list.appendUnique(pname);

}

}

}

file.close();

} catch (IOException e) {

System.err.println("Ignoring " + filename + " (" + e.getMessage() + ")");

//e.printStackTrace();

}

}

/**

static private void packageListFromFolder(File dir, String sofar,

StringList list) {

boolean foundClass = false;

String files[] = dir.list();

for (int i = 0; i < files.length; i++) {

if (files[i].equals(".") || files[i].equals("..")) continue;

File sub = new File(dir, files[i]);

if (sub.isDirectory()) {

String nowfar =

(sofar == null) ? files[i] : (sofar + "." + files[i]);

packageListFromFolder(sub, nowfar, list);

//System.out.println(nowfar);

//imports[importCount++] = nowfar;

//importCount = magicImportsRecursive(sub, nowfar,

// imports, importCount);

} else if (!foundClass) { // if no classes found in this folder yet

if (files[i].endsWith(".class")) {

//System.out.println("unique class: " + files[i] + " for " + sofar);

list.appendUnique(sofar);

foundClass = true;

}

}

}

}

static public void unzip(File zipFile, File dest) {

try {

FileInputStream fis = new FileInputStream(zipFile);

CheckedInputStream checksum = new CheckedInputStream(fis, new Adler32());

ZipInputStream zis = new ZipInputStream(new BufferedInputStream(checksum));

ZipEntry next = null;

while ((next = zis.getNextEntry()) != null) {

File currentFile = new File(dest, next.getName());

if (next.isDirectory()) {

currentFile.mkdirs();

} else {

File parentDir = currentFile.getParentFile();

// Sometimes the directory entries aren't already created

if (!parentDir.exists()) {

parentDir.mkdirs();

}

currentFile.createNewFile();

unzipEntry(zis, currentFile);

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

static protected void unzipEntry(ZipInputStream zin, File f) throws IOException {

FileOutputStream out = new FileOutputStream(f);

byte[] b = new byte[512];

int len = 0;

while ((len = zin.read(b)) != -1) {

out.write(b, 0, len);

}

out.flush();

out.close();

}

static public byte[] gzipEncode(byte[] what) throws IOException {

ByteArrayOutputStream baos = new ByteArrayOutputStream();

GZIPOutputStream output = new GZIPOutputStream(baos);

PApplet.saveStream(output, new ByteArrayInputStream(what));

output.close();

return baos.toByteArray();

}

static public final boolean containsNonASCII(String what) {

for (char c : what.toCharArray()) {

if (c < 32 || c > 127) return true;

}

return false;

}