+ * Private constructor to prevent initializing of the class.
+ *
+ */
+ private ArrayTools() {
+
+ }
+
+ /**
+ *
+ * Finds the first occurrence of an object inside an array.
+ *
+ *
+ * In case {@code other==null}, the first occurrence of a {@code null} value
+ * in the array is returned.
+ *
+ *
+ * @param array
+ * the array
+ * @param other
+ * the object
+ * @return index of the object if found, -1 otherwise
+ */
+ public static int findIndex(Object[] array, Object other) {
+ int retVal = -1;
+ for (int i = 0; i < array.length && retVal == -1; i++) {
+ if (other != null) {
+ if (array[i] != null && array[i].equals(other)) {
+ retVal = i;
+ }
+ } else {
+ if (array[i] == null) {
+ retVal = i;
+ }
+ }
+ }
+ return retVal;
+ }
+
+ /**
+ *
+ * Finds the highest element in an array. If multiple elements have the
+ * maximum value, the index of the first one is returned; null-values are
+ * ignored. In case the parameter array is null, has length 0 or contains
+ * only null-values, -1 is returned.
+ *
+ *
+ * @param
+ * @param array
+ * the array
+ * @return index of the element with the highest value, -1 in case of an
+ * invalid parameter
+ */
+ @SuppressWarnings("unchecked")
+ public static int findMax(Comparable[] array) {
+ int maxIndex = -1;
+ T maxElement = null;
+ if (array != null) {
+ for (int i = 0; i < array.length; i++) {
+ if (array[i] != null) {
+ if (maxElement == null
+ || array[i].compareTo(maxElement) > 0) {
+ maxElement = (T) array[i];
+ maxIndex = i;
+ }
+ }
+ }
+ }
+ return maxIndex;
+ }
+
+ /**
+ *
+ * Finds the highest element in an array. If multiple elements have the
+ * maximum value, the index of the first one is returned; null-values are
+ * ignored. In case the parameter array is null, has length 0 or contains
+ * only null-values, -1 is returned.
+ *
+ *
+ * @param array
+ * the array
+ * @return index of the element with the highest value, -1 in case of an
+ * invalid parameter
+ */
+ public static int findMax(double[] array) {
+ int maxIndex = -1;
+ double maxElement = -Double.MAX_VALUE;
+ if (array != null) {
+ for (int i = 0; i < array.length; i++) {
+ if (array[i] > maxElement) {
+ maxElement = array[i];
+ maxIndex = i;
+ }
+ }
+ }
+ return maxIndex;
+ }
+
+ /**
+ *
+ * Finds the lowest element in an array. If multiple elements have the
+ * minimal value, the index of the first one is returned; null-values are
+ * ignored. In case the parameter array is null, has length 0 or contains
+ * only null-values, -1 is returned.
+ *
+ *
+ * @param
+ * @param array
+ * the array
+ * @return index of the element with the lowest value, -1 in case of an
+ * invalid parameter
+ */
+ @SuppressWarnings("unchecked")
+ public static int findMin(Comparable[] array) {
+ int maxIndex = -1;
+ T maxElement = null;
+ if (array != null) {
+ for (int i = 0; i < array.length; i++) {
+ if (array[i] != null) {
+ if (maxElement == null
+ || array[i].compareTo(maxElement) < 0) {
+ maxElement = (T) array[i];
+ maxIndex = i;
+ }
+ }
+ }
+ }
+ return maxIndex;
+ }
+}
Index: /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/FileTools.java
===================================================================
--- /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/FileTools.java (revision 1470)
+++ /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/FileTools.java (revision 1470)
@@ -0,0 +1,187 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.util;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+
+/**
+ *
+ * Helper class that provides methods that simplify working with files.
+ *
+ * Private constructor to prevent initializing of the class.
+ *
+ */
+ private FileTools() {
+
+ }
+
+ /**
+ *
+ * Returns an array of the lines contained in a file. The line separator is
+ * {@link StringTools#ENDLINE}.
+ *
+ *
+ * @param filename
+ * name of the file
+ * @return string array, where each line contains a file
+ * @throws IOException
+ * see {@link FileReader#read(char[])}, {@link FileReader#close()}
+ * @throws FileNotFoundException
+ * see {@link FileReader#FileReader(File)}
+ */
+ public static String[] getLinesFromFile(String filename) throws IOException,
+ FileNotFoundException
+ {
+ boolean carriageReturn = true;
+ if (StringTools.ENDLINE.equals("\n")) {
+ carriageReturn = false;
+ }
+ return getLinesFromFile(filename, carriageReturn);
+ }
+
+ /**
+ *
+ * Returns an array of the lines contained in a file.
+ *
+ *
+ * @param filename
+ * name of the file
+ * @param carriageReturn
+ * if true, "\r\n", if false "\n" is used as line separator
+ * @return string array, where each line contains a file
+ * @throws IOException
+ * see {@link FileReader#read(char[])}, {@link FileReader#close()}
+ * @throws FileNotFoundException
+ * see {@link FileReader#FileReader(File)}
+ */
+ public static String[] getLinesFromFile(String filename, boolean carriageReturn)
+ throws IOException, FileNotFoundException
+ {
+ File f = new File(filename);
+ FileInputStream fis = new FileInputStream(f);
+ InputStreamReader reader = new InputStreamReader(fis, Charset.defaultCharset());
+ char[] buffer = new char[(int) f.length()];
+ reader.read(buffer);
+ reader.close();
+ String splitString;
+ if (carriageReturn) {
+ splitString = "\r\n";
+ }
+ else {
+ splitString = "\n";
+ }
+ return (new String(buffer)).split(splitString);
+ }
+
+ /**
+ *
+ * Writes an array to a file using the toString function of its object.
+ *
+ *
+ * @param array
+ * array that is written
+ * @param filename
+ * name of the output file
+ * @param separator
+ * separator string that is put between the array objects
+ * @param lineBreak
+ * if true, a new line is added after each array element and its separator
+ * @throws IOException
+ * see {@link BufferedWriter#write(String)}, {@link BufferedWriter#newLine()},
+ * {@link BufferedWriter#flush()}, {@link BufferedWriter#close()},
+ * {@link FileWriter#FileWriter(String)}
+ */
+ public static void writeArrayToFile(T[] array,
+ String filename,
+ String separator,
+ boolean lineBreak) throws IOException
+ {
+ BufferedWriter outputWriter = null;
+ outputWriter = new BufferedWriter(new FileWriter(filename));
+ for (int i = 0; i < array.length; i++) {
+ outputWriter.write(array[i].toString());
+ if (i < array.length - 1) {
+ outputWriter.write(separator);
+ if (lineBreak) {
+ outputWriter.newLine();
+ }
+ }
+ }
+ outputWriter.flush();
+ outputWriter.close();
+ }
+
+ /**
+ *
+ * Autocompletes a given path. The path must be absolute. Otherwise, autocompletion is not
+ * possible.
+ *
+ *
+ * @param prefix
+ * the prefix to be complete
+ * @return the auto completed path
+ */
+ public static String autoCompletePath(String prefix) {
+ File prefixFile = new File(prefix);
+ File parentDir = prefixFile.getParentFile();
+
+ if (parentDir == null) {
+ // the prefix does not denote a path or denotes one of the root directories.
+ // this can not be auto completed
+ return prefix;
+ }
+
+ String[] completions = null;
+
+ if (parentDir.exists()) {
+ completions = parentDir.list();
+ }
+
+ if (completions == null) {
+ completions = new String[0];
+ }
+
+ String completedPrefix;
+
+ completedPrefix = StringTools.autocomplete(prefixFile.getName(), completions);
+
+ File completedFile = new File(parentDir, completedPrefix);
+
+ if (completedFile.exists() && completedFile.isDirectory()) {
+ return completedFile.getAbsolutePath() + File.separator;
+ }
+ else {
+ return (parentDir.getAbsolutePath() + File.separator + completedPrefix)
+ .replaceAll("//", "/");
+ }
+ }
+
+}
Index: /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StopWatch.java
===================================================================
--- /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StopWatch.java (revision 1470)
+++ /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StopWatch.java (revision 1470)
@@ -0,0 +1,315 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.util;
+
+import java.io.PrintStream;
+import java.text.DecimalFormat;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * This is a simple implementation for a stop watch that can be used for performance measures.
+ * A stop watch can be used to measure several splits. Each split is started and stopped using the
+ * same id provided to the {@link #start(String)} and {@link #stop(String)} methods. The measured
+ * durations can be retrieved afterwards using {@link #getDuration(String)}.
+ * {@link #dumpStatistics(PrintStream)} is a convenience method useful to effectively dump all
+ * information for the different splits.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class StopWatch {
+
+ /**
+ * the splits hold internally
+ */
+ private Map mSplits = new HashMap();
+
+ /**
+ * starts a split with the given id. If the split with the id is already started, an
+ * {@link IllegalStateException} is thrown.
+ *
+ * @param id the id of the split to be started
+ *
+ * @throws IllegalStateException if the split is already started
+ */
+ public void start(String id) throws IllegalStateException {
+ Split split = mSplits.get(id);
+
+ if (split == null) {
+ split = new Split(id);
+ mSplits.put(id, split);
+ }
+
+ split.start();
+ }
+
+ /**
+ * stops a split with the given id. If the split with the id is already stopped, an
+ * {@link IllegalStateException} is thrown. If no split with the given id exists, an
+ * {@link IllegalArgumentException} is thrown.
+ *
+ * @param id the id of the split to be stopped
+ *
+ * @throws IllegalStateException if the split is not running
+ * @throws IllegalArgumentException if the split with the given id does not exist
+ */
+ public void stop(String id) throws IllegalStateException, IllegalArgumentException {
+ Split split = mSplits.get(id);
+
+ if (split == null) {
+ throw new IllegalArgumentException("split with id " + id + " does not exist");
+ }
+
+ split.stop();
+ }
+
+ /**
+ * returns the duration of a split with the given id. If the split with the id is currently
+ * running, it is stopped. If no split with the given id exists, an
+ * {@link IllegalArgumentException} is thrown.
+ *
+ * @param id the id of the split for which the duration shall be returned
+ *
+ * @return the duration measured for the split
+ *
+ * @throws IllegalArgumentException if the split with the given id does not exist
+ */
+ public long getDuration(String id) throws IllegalArgumentException {
+ Split split = mSplits.get(id);
+
+ if (split == null) {
+ throw new IllegalArgumentException("split with id " + id + " does not exist");
+ }
+
+ if (split.isRunning()) {
+ split.stop();
+ }
+
+ return split.getDuration();
+ }
+
+ /**
+ * resets the stop watch and clears all splits
+ */
+ public void reset() {
+ mSplits.clear();
+ }
+
+ /**
+ * dumps the statistics about the splits. Splits still running are stopped. The method checks
+ * if the longest split also covers the other splits. If so, it considers this split as a
+ * kind of overall duration and dumps the proportion of all other splits to this split in
+ * percentage.
+ *
+ * @param out the stream to dump the statistics to
+ */
+ public void dumpStatistics(PrintStream out) {
+ if (mSplits.size() <= 0) {
+ throw new IllegalStateException("no splits registered that could be dumped");
+ }
+
+ Map durations = new HashMap();
+
+ // get durations
+ for (String id : mSplits.keySet()) {
+ durations.put(id, getDuration(id));
+ }
+
+ // sort by duration
+ List sortedIds = new LinkedList();
+ int maxIdLength = 0;
+
+ for (Map.Entry entry : durations.entrySet()) {
+ boolean added = false;
+ for (int i = 0; i < sortedIds.size(); i++) {
+ if (durations.get(sortedIds.get(i)) >= entry.getValue()) {
+ sortedIds.add(i, entry.getKey());
+ added = true;
+ break;
+ }
+ }
+
+ if (!added) {
+ sortedIds.add(entry.getKey());
+ }
+
+ maxIdLength = Math.max(maxIdLength, entry.getKey().length());
+ }
+
+ // get longest duration and check whether it spans all other entries
+ String id = sortedIds.get(sortedIds.size() - 1);
+ Split longestWatch = mSplits.get(id);
+ boolean longestDurationCoversOthers = true;
+
+ for (Map.Entry watch : mSplits.entrySet()) {
+ if ((watch.getValue().getFirstStart() < longestWatch.getFirstStart()) ||
+ (watch.getValue().getLastStop() > longestWatch.getLastStop()))
+ {
+ longestDurationCoversOthers = false;
+ break;
+ }
+ }
+
+ // no finally start the dumping
+ out.println();
+ out.println("Watch Statistics");
+ out.println("================");
+
+ for (String sortedId : sortedIds) {
+ out.print(sortedId);
+
+ for (int i = sortedId.length(); i <= maxIdLength; i++) {
+ out.print(' ');
+ }
+
+ out.print(": ");
+
+ out.print(durations.get(sortedId));
+ out.print(" ms");
+
+ out.print(" (");
+ out.print(mSplits.get(sortedId).getNoOfStarts());
+ out.print(" starts");
+
+ //out.print(", ");
+ //out.print(1000 * durations.get(sortedId) / mSplits.get(sortedId).getNoOfStarts());
+ //out.print(" ms per 1000 starts");
+
+ if (longestDurationCoversOthers) {
+ out.print(", ");
+ out.print(DecimalFormat.getPercentInstance().format
+ ((double) durations.get(sortedId) / longestWatch.getDuration()));
+ out.print(" of overall duration");
+ }
+
+ out.println(')');
+ }
+
+ out.println();
+ }
+
+ /**
+ * internally used to store splits
+ */
+ private static class Split {
+
+ /**
+ * the id of the split
+ */
+ private String id;
+
+ /**
+ * the system time of the first start of the split
+ */
+ private long firstStart = -1;
+
+ /**
+ * the system time of the last start of the split
+ */
+ private long lastStart = -1;
+
+ /**
+ * the system time of the last stop of the split
+ */
+ private long lastStop = -1;
+
+ /**
+ * the duration so far for the split (excluding the time since the last start)
+ */
+ private long duration = 0;
+
+ /**
+ * the number of starts or the splits
+ */
+ private long noOfStarts = 0;
+
+ /**
+ * initializes the split with its id
+ */
+ private Split(String id) {
+ this.id = id;
+ }
+
+ /**
+ * starts the split if it is not already started
+ */
+ private void start() throws IllegalStateException {
+ if (lastStart > -1) {
+ throw new IllegalStateException("split with id " + id + " already running");
+ }
+
+ lastStart = System.currentTimeMillis();
+
+ if (firstStart < 0) {
+ firstStart = lastStart;
+ }
+
+ noOfStarts++;
+ }
+
+ /**
+ * checks if the split is currently running
+ */
+ private boolean isRunning() {
+ return (lastStart > -1);
+ }
+
+ /**
+ * stops the split if it is not already stopped
+ */
+ private void stop() throws IllegalStateException {
+ if (lastStart < 0) {
+ throw new IllegalStateException("split with id " + id + " not running");
+ }
+
+ lastStop = System.currentTimeMillis();
+ duration += lastStop - lastStart;
+ lastStart = -1;
+ }
+
+ /**
+ * returns the fist start of the split
+ */
+ private long getFirstStart() {
+ return firstStart;
+ }
+
+ /**
+ * returns the last stop of the split
+ */
+ private long getLastStop() {
+ return lastStop;
+ }
+
+ /**
+ * returns the duration of the split measured so far excluding the time since the last
+ * start if the split is currently started
+ */
+ private long getDuration() {
+ return duration;
+ }
+
+ /**
+ * returns the number of starts for the split
+ */
+ private long getNoOfStarts() {
+ return noOfStarts;
+ }
+ }
+}
Index: /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StringTools.java
===================================================================
--- /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StringTools.java (revision 1470)
+++ /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/StringTools.java (revision 1470)
@@ -0,0 +1,123 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * Helper class that provides methods to simplify working with {@link String}s.
+ *
+ * Private constructor to prevent initializing of the class.
+ *
+ */
+ private StringTools() {
+
+ }
+
+ /**
+ *
+ * Simplifies use of operation system specific line separators.
+ *
+ */
+ public final static String ENDLINE = System.getProperty("line.separator");
+
+ /**
+ *
+ * Replaces all occurrences of {@literal &, <, >, ', and "} with their respective XML entities
+ * {@literal &, <, >, ', and "} without destroying already existing
+ * entities.
+ *
+ *
+ * @param str
+ * String where the XML entities are to be replaced
+ * @return new String, where the XML entities are used instead of the literals
+ */
+ public static String xmlEntityReplacement(String str) {
+ String result = str;
+ if (result != null && !"".equals(result)) {
+ result = result.replaceAll("&(?!(?:lt|gt|apos|quot|amp);)", "&");
+ result = result.replaceAll("<", "<");
+ result = result.replaceAll(">", ">");
+ result = result.replaceAll("'", "'");
+ result = result.replaceAll("\"", """);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * Performs an auto completion of the provided prefix using the given potential completions.
+ * The method searches for all completions that start with the given prefix and stores them in
+ * a subset. It then extends the prefix with characters of the subset of completions as long as
+ * the prefix still prefixes all completions in the subset. The result is then returned. If
+ * there is no matching completion or if there are several matching completions differing
+ * in the succeeding letter, the prefix is returned as is. If there is only one matching
+ * completion this completion is returned.
+ *
+ *
+ * @param prefix the prefix to be further completed
+ * @param completions the potential completions of the prefix
+ *
+ * @return as described
+ */
+ public static String autocomplete(String prefix, String[] completions) {
+ List matchingCompletions = new ArrayList();
+ for (String completion : completions) {
+ if (completion.startsWith(prefix)) {
+ matchingCompletions.add(completion);
+ }
+ }
+
+ StringBuffer completedPrefix = new StringBuffer(prefix);
+
+ boolean foundCompletion = false;
+
+ while (!foundCompletion) {
+ char nextCompletionChar = 0;
+ for (String completion : matchingCompletions) {
+ if (completion.length() > completedPrefix.length()) {
+ if (nextCompletionChar == 0) {
+ nextCompletionChar = completion.charAt(completedPrefix.length());
+ }
+ else if (nextCompletionChar != completion.charAt(completedPrefix.length())) {
+ foundCompletion = true;
+ }
+ }
+ else {
+ foundCompletion = true;
+ }
+ }
+
+ if (!foundCompletion && (nextCompletionChar != 0)) {
+ completedPrefix.append(nextCompletionChar);
+ }
+ else {
+ foundCompletion = true;
+ }
+ }
+
+ return completedPrefix.toString();
+ }
+}
Index: /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/console/Command.java
===================================================================
--- /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/console/Command.java (revision 1470)
+++ /tags/java-utils-0.1.0/src/main/java/de/ugoe/cs/util/console/Command.java (revision 1470)
@@ -0,0 +1,48 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.util.console;
+
+import java.util.List;
+
+/**
+ *
+ * Defines the interface for a command. The class names of the commands must be
+ * of the form {@code CMD}, otherwise they cannot be used by the
+ * {@link CommandExecuter}.
+ *