src/treeProperties/PropertyElement.java

@@ -0,0 +1,38 @@
+/**
+ * PropertyElement.java
+ * 
+ * Created on 19.08.2009
+ */
+
+package treeProperties;
+
+
+
+
+/**
+ * The class PropertyElement.
+ * 
+ * @version V0.0 19.08.2009
+ * @author Clemens Koza
+ */
+public interface PropertyElement {
+    /**
+     * Returns the key of the property in the TreeProperties.
+     */
+    public String getKey();
+    
+    /**
+     * Returns the type of the element.
+     */
+    public Class<?> getType();
+    
+    /**
+     * Returns the value of the element.
+     */
+    public Object getValue();
+    
+    /**
+     * Sets the property value as a string.
+     */
+    public void setValue(String value);
+}

src/treeProperties/PropertyType.java

@@ -0,0 +1,34 @@
+
+package treeProperties;
+
+
+/**
+ * PropertyTypeHandler.java
+ * 
+ * Created on 19.08.2009
+ */
+
+
+/**
+ * The class PropertyType. A property type is used to process special, suffixed entries in a {@link TreeProperties}
+ * ' properties-file
+ * 
+ * @version V0.0 19.08.2009
+ * @author Clemens Koza
+ */
+public interface PropertyType<T> {
+    /**
+     * The suffix, not including "--", that identifies this content type.
+     */
+    public String getSuffix();
+    
+    /**
+     * The class that identifies this content type.
+     */
+    public Class<T> getType();
+    
+    /**
+     * Returns an object for the specified value, in the context of a TreeProperties.
+     */
+    public T toObject(TreeProperties p, String s);
+}

src/treeProperties/TreeProperties.java

@@ -0,0 +1,396 @@
+
+package treeProperties;
+
+
+/**
+ *  TreeProperties.java
+ * 
+ * Created on 19.08.2009
+ */
+
+
+import static java.lang.String.*;
+import static java.util.Collections.*;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Properties;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import treeProperties.types.FileType;
+
+
+/**
+ * The class TreeProperties. This class allows for a tree-like structure of properties-files. This class lays some
+ * restrictions on the keys used in properties-files:
+ * <ul>
+ * <li>The use of "--" is forbidden</li>
+ * <li>The suffixes "--properties" and "--transparent-properties" are reserved for specifying additional
+ * properties-files in the tree (relative paths are relative to the properties-file where they are referenced)</li>
+ * <li>Other suffixes are used by {@link PropertyType}s. PropertyTypes are registered or unregistered using
+ * {@link #addType(PropertyType)} or {@link #removeType(PropertyType)}.</li>
+ * </ul>
+ * Take a look at these files:
+ * 
+ * <pre>
+ * #root.properties
+ * title=directions
+ * icons--properties=img/icons.properties
+ * 
+ * #img/icons.properties
+ * left--file=left.jpg
+ * right--file=right.jpg
+ * up--file=up.jpg
+ * down--file=down.jpg
+ * #note that the path does not contain &quot;img/&quot;
+ * size--transparent-properties=size.properties
+ * 
+ * #img/size.properties
+ * width=20
+ * height=20
+ * </pre>
+ * 
+ * These properties are retrieved with
+ * 
+ * <pre>
+ * getProperty(&quot;title&quot;) //directions
+ * getFile(&quot;icons/left&quot;) //img/left.jpg
+ * getFile(&quot;icons/right&quot;) //img/right.jpg
+ * getFile(&quot;icons/up&quot;) //img/up.jpg
+ * getFile(&quot;icons/down&quot;) //img/down.jpg
+ * getProperty(&quot;icons/width&quot;) //20
+ * getProperty(&quot;icons/height&quot;) //20
+ * </pre>
+ * 
+ * As you can see, a properties file included with "--transparent-properties" hides its existence from the user. A
+ * file included with "--properties" is not hidden. The child properties are accessible as if their keys were
+ * prepended with the parent key, separated by a slash.
+ * 
+ * Note that --file, --properties and --transparent-properties entries will be relative to the included file, even
+ * if the properties file is transparent.
+ * 
+ * Also, the TreeProperties can be retrieved:
+ * 
+ * <pre>
+ * getChildProperties(&quot;icons&quot;)
+ * getTransparentProperties(&quot;icons/size&quot;)
+ * </pre>
+ * 
+ * 
+ * TODO add edit & save support
+ * 
+ * @version V0.0 19.08.2009
+ * @author Clemens Koza
+ * @see Properties
+ */
+public class TreeProperties implements Iterable<PropertyElement> {
+    private static final Map<String, PropertyType<?>>   suffixes;
+    private static final Map<Class<?>, PropertyType<?>> types;
+    
+    private static final String                         transparent = "transparent-properties";
+    private static final String                         child       = "properties";
+    
+    static {
+        types = new HashMap<Class<?>, PropertyType<?>>();
+        suffixes = new HashMap<String, PropertyType<?>>();
+        PropertyType<?>[] pt = {new FileType()};
+        for(PropertyType<?> type:pt) {
+            addType(type);
+        }
+    }
+    
+    private File                                        path;
+    private Map<Class<?>, PropertyType<?>>              instanceTypes;
+    private Map<String, PropertyType<?>>                instanceSuffixes;
+    private HashMap<String, Object>                     properties;
+    private List<Exception>                             exceptions;
+    
+    public static void addType(PropertyType<?> type) {
+        types.put(type.getType(), type);
+        suffixes.put(type.getSuffix(), type);
+    }
+    
+    public static void removeType(PropertyType<?> type) {
+        types.remove(type.getType());
+        suffixes.remove(type.getSuffix());
+    }
+    
+    /**
+     * Delegate to {@link #TreeProperties(File)} with a new {@link File#File(String)}
+     */
+    public TreeProperties(String f) throws IOException {
+        this(new File(f));
+    }
+    
+    /**
+     * Delegate to {@link #TreeProperties(File)} with a new {@link File#File(File, String)}
+     */
+    public TreeProperties(File parent, String f) throws IOException {
+        this(new File(parent, f));
+    }
+    
+    /**
+     * The constructor is forgiving in the way that Exceptions are not directly forwarded. The only fatal exception
+     * is if the parameter is null or not found. Instead, the rest of the properties are processed, so that the
+     * erroneous properties are the only ones not present in this TreeProperties. Afterwards, the exceptions can be
+     * accessed.
+     */
+    public TreeProperties(File f) throws IOException {
+        if(f == null) throw new FileNotFoundException("null");
+        this.path = f.getParentFile();
+        instanceTypes = new HashMap<Class<?>, PropertyType<?>>(types);
+        instanceSuffixes = new HashMap<String, PropertyType<?>>(suffixes);
+        Properties p = new Properties();
+        
+//        BufferedReader r = new BufferedReader(new FileReader(f));
+//        p.load(r);
+//        r.close();
+        BufferedInputStream is = new BufferedInputStream(new FileInputStream(f));
+        p.load(is);
+        is.close();
+        
+        Set<Entry<Object, Object>> entries = p.entrySet();
+        properties = new HashMap<String, Object>();
+        List<Exception> exceptions = new ArrayList<Exception>();
+        this.exceptions = unmodifiableList(exceptions);
+        for(Entry<Object, Object> entry:entries) {
+            String key = (String) entry.getKey();
+            String value = (String) entry.getValue();
+            try {
+                String[] parts = key.split("--", 2);
+                Object result;
+                if(parts.length == 1) {
+                    //Regular
+                    result = value;
+                } else {
+                    //suffix
+                    if(parts[1].equals(transparent) || parts[1].equals(child)) {
+                        TreeProperties child = new TreeProperties(path, FileType.getPath(value));
+                        exceptions.addAll(child.exceptions);
+                        result = child;
+                    } else {
+                        PropertyType<?> t = instanceSuffixes.get(parts[1]);
+                        if(t == null) throw new IllegalArgumentException("No content type: " + parts[1]);
+                        result = t.toObject(this, value);
+                    }
+                }
+                properties.put(key, result);
+            } catch(Exception ex) {
+                exceptions.add(new Exception(format("File '%s', Property '%s':%n    %s", f, key, ex.getMessage()),
+                        ex.getCause()));
+            }
+        }
+    }
+    
+    /**
+     * Returns the exceptions that were thrown while creating the tree properties.
+     */
+    public List<Exception> getExceptions() {
+        return exceptions;
+    }
+    
+    /**
+     * If exceptions occured during construction, this method throws an IOException that combines the messages of
+     * those exceptions.
+     */
+    public void rethrow() throws IOException {
+        if(exceptions.isEmpty()) return;
+        StringBuilder sb = new StringBuilder("The following exceptions occured:");
+        for(Exception ex:exceptions) {
+            sb.append("\n");
+            sb.append(ex.getMessage());
+        }
+        throw new IOException(sb.toString());
+    }
+    
+    /**
+     * Returns the parent directory of this TreeProperties.
+     */
+    public File getPath() {
+        return path;
+    }
+    
+    /**
+     * Checks if the key is valid for a query and throws an {@link IllegalArgumentException} if not. Slashes are
+     * allowed in this method, but suffixes are not
+     */
+    private void checkQueryKey(String key) {
+        if(key.contains("--")) throw new IllegalArgumentException("Invalid key: " + key);
+    }
+    
+    /**
+     * Retrieves the string property for the given key.
+     */
+    public String getProperty(String key) {
+        return getProperty(key, String.class);
+    }
+    
+    /**
+     * Convenience for {@code getProperty(key, File.class)}.
+     */
+    public File getFile(String key) {
+        return getProperty(key, File.class);
+    }
+    
+    /**
+     * Retrieves the child properties for the given key. Transparent properties can't be retrieved this way.
+     */
+    public TreeProperties getChildProperties(String key) {
+        return (TreeProperties) getProperty(key, "--" + child);
+    }
+    
+    /**
+     * Retrieves the child properties for the given key.
+     */
+    public TreeProperties getTransparentProperties(String key) {
+        return (TreeProperties) getProperty(key, "--" + transparent);
+    }
+    
+    /**
+     * Returns a property of the given type. This does not work to retrieve tree properties.
+     */
+    @SuppressWarnings("unchecked")
+	public <T> T getProperty(String key, Class<T> cls) {
+        String suffix;
+        if(cls == String.class) suffix = "";
+        else {
+            PropertyType<?> t = instanceTypes.get(cls);
+            suffix = "--" + t.getSuffix();
+        }
+        return (T) getProperty(key, suffix);
+    }
+    
+    private Object getProperty(String key, String suffix) {
+        checkQueryKey(key);
+        //first, try the key in the current file, as if there were no slash
+        //No subpath - either directly in the properties...
+        Object result;
+        if((result = properties.get(key + suffix)) != null) return result;
+        
+        //...or in a transparent properties
+        
+        //look for all --transparent-properties
+        for(Entry<String, Object> entry:properties.entrySet()) {
+            if(entry.getKey().endsWith("--" + transparent)) {
+                TreeProperties p = (TreeProperties) entry.getValue();
+                if((result = p.getProperty(key, suffix)) != null) {
+                    return result;
+                }
+            }
+        }
+        
+        //if there is no immediate containment, try the children
+        //try every combination
+        //for a/b/c, there could be a child "a/b--properties" that contains "c"
+        //or "a--properties" with "b/c"
+        int index = -1;
+        while((index = key.indexOf('/', index + 1)) != -1) {
+            String first = key.substring(0, index), second = key.substring(index + 1);
+            
+            TreeProperties p = (TreeProperties) getProperty(first, "--" + child);
+            if(p == null) continue;
+            if((result = p.getProperty(second, suffix)) != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+    
+    /**
+     * Returns an iterator over all the regular entries of this object. That means that transparent or child tree
+     * properties are not included.
+     */
+    public Iterator<PropertyElement> iterator() {
+        return iterator("");
+    };
+    
+    private TreePropertiesIterator iterator(String prefix) {
+        return new TreePropertiesIterator(prefix);
+    }
+    
+    private final class TreePropertiesIterator implements Iterator<PropertyElement> {
+        private final String                    prefix;
+        private Iterator<Entry<String, Object>> entries;
+        private TreePropertiesIterator          child;
+        private PropertyElement                 next;
+        
+        private TreePropertiesIterator(String prefix) {
+            entries = properties.entrySet().iterator();
+            this.prefix = prefix;
+        }
+        
+        //After this call, the next element is determined, or the child iterator has next
+
+        public boolean hasNext() {
+            if(next != null) return true;
+            else if(child != null && child.hasNext()) return true;
+            else if(entries.hasNext()) {
+                Entry<String, Object> entry = entries.next();
+                final String[] parts = entry.getKey().split("--");
+                final Class<?> cls;
+                final Object value = entry.getValue();
+                
+                if(parts.length == 1) {
+                    cls = String.class;
+                } else if(parts[1].equals(transparent)) {
+                    child = ((TreeProperties) entry.getValue()).iterator(prefix);
+                    //recursive, for the case that the child iterator is empty
+                    return hasNext();
+                } else if(parts[1].equals(TreeProperties.child)) {
+                    child = ((TreeProperties) entry.getValue()).iterator(prefix + parts[0] + "/");
+                    //recursive, for the case that the child iterator is empty
+                    return hasNext();
+                } else {
+                    //class is determined by the content type
+                    PropertyType<?> t = instanceSuffixes.get(parts[1]);
+                    cls = t.getType();
+                }
+                next = new PropertyElement() {
+
+                    public String getKey() {
+                        return prefix + parts[0];
+                    }
+                    
+
+                    public Class<?> getType() {
+                        return cls;
+                    }
+                    
+
+                    public Object getValue() {
+                        return value;
+                    }
+                    
+
+                    public void setValue(String value) {}
+                };
+                return true;
+            } else return false;
+        }
+        
+
+        public PropertyElement next() {
+            if(!hasNext()) throw new NoSuchElementException();
+            else if(next != null) {
+                PropertyElement next = this.next;
+                this.next = null;
+                return next;
+            } else return child.next();
+        }
+        
+
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}

src/treeProperties/types/FileType.java

@@ -0,0 +1,61 @@
+/**
+ * FileType.java
+ * 
+ * Created on 19.08.2009
+ */
+
+package treeProperties.types;
+
+
+import java.io.File;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import treeProperties.PropertyType;
+import treeProperties.TreeProperties;
+
+
+/**
+ * The class FileType.
+ * 
+ * @version V0.0 19.08.2009
+ * @author Clemens Koza
+ */
+public class FileType implements PropertyType<File> {
+    public static final String      suffix = "file";
+    public static final Class<File> type   = File.class;
+    
+    public String getSuffix() {
+        return suffix;
+    }
+
+    public Class<File> getType() {
+        return type;
+    }
+    
+
+    public File toObject(TreeProperties p, String s) {
+        return new File(p.getPath(), getPath(s));
+    }
+    
+    /**
+     * Returns a path path from a property value. Three substitutions are applied:
+     * <ul>
+     * <li>A "~/" or "~\" at the beginning is replaced with the user's home directory</li>
+     * <li>A "$$" anywhere is replaced with a single "$"</li>
+     * <li>A "${*}", where * is any string without "}", is replaced by {@link System#getProperty(String)}</li>
+     * </ul>
+     */
+    public static String getPath(String s) {
+        if(s.startsWith("~/")) s = System.getProperty("user.home") + "/" + s.substring(2);
+        else if(s.startsWith("~\\")) s = System.getProperty("user.home") + "\\" + s.substring(2);
+        Matcher m = Pattern.compile("\\$\\$|\\$\\{([^\\}]*)\\}").matcher(s);
+        StringBuffer result = new StringBuffer();
+        while(m.find()) {
+            if(m.group().equals("$$")) m.appendReplacement(result, Matcher.quoteReplacement("$"));
+            else m.appendReplacement(result, Matcher.quoteReplacement(System.getProperty(m.group(1))));
+        }
+        m.appendTail(result);
+        return result.toString();
+    }
+}