toxiclibs 0.4.0 → 0.8.0

data/src/toxi/util/datatypes/SingletonRegistry.java

@@ -0,0 +1,91 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library 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
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.util.datatypes;
+
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Implements a registry for dynamic singleton management. Use this registry
+ * instead of using "new" to enforce singletons of any class with a visible
+ * default constructor. The registry itself is implemented as singleton.
+ */
+public class SingletonRegistry {
+
+    /**
+     * The singleton instance of the registry itself.
+     */
+    public static final SingletonRegistry REGISTRY = new SingletonRegistry();
+
+    private static final HashMap<String, Object> map = new HashMap<>();
+
+    private static final Logger logger = Logger.getLogger(SingletonRegistry.class
+            .getName());
+
+    /**
+     * Creates or returns an instance of the class requested by name.
+     * 
+     * @param className
+     * @return class singleton instance
+     */
+    public static synchronized Object getInstanceOf(String className) {
+        Object instance = map.get(className);
+        if (instance != null) {
+            return instance;
+        }
+        try {
+            instance = Class.forName(className).newInstance();
+            map.put(className, instance);
+            logger.log(Level.INFO, "Created singleton: {0}", instance);
+        } catch (ClassNotFoundException cnf) {
+            logger.log(Level.SEVERE, "Couldn''t find class: {0}", className);
+        } catch (InstantiationException ie) {
+            logger.log(Level.SEVERE, "Couldn''t instantiate the class: {0}", className);
+        } catch (IllegalAccessException ia) {
+            logger.log(Level.SEVERE, "Couldn''t access class: {0}", className);
+        }
+        return instance;
+    }
+
+    /**
+     * Alternative, more conventional accessor to the singleton instance of the
+     * registry itself.
+     * 
+     * @return registry instance
+     */
+    public static SingletonRegistry getRegistry() {
+        return REGISTRY;
+    }
+
+    /**
+     *
+     */
+    protected SingletonRegistry() {
+    }
+}

data/src/toxi/util/datatypes/TypedProperties.java

@@ -0,0 +1,291 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library 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
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.util.datatypes;
+
+import java.io.FileInputStream;
+import java.util.HashMap;
+import java.util.Properties;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Convenience wrapper providing typed access to Java {@link Properties} files.
+ */
+@SuppressWarnings("serial")
+public class TypedProperties extends Properties {
+
+    /**
+     *
+     */
+    public static final String DELIM = "\t\n\r\f\u00A0,";
+
+    private static final Logger logger = Logger.getLogger(TypedProperties.class
+            .getName());
+
+    /**
+     * Returns a property as boolean.
+     * 
+     * @param id
+     *            property name
+     * @param defaultState
+     * @return prop value
+     */
+    public boolean getBoolean(String id, boolean defaultState) {
+        return Boolean.parseBoolean(getProperty(id, "" + defaultState));
+    }
+
+    /**
+     * Shorthand wrapper for {@link #getByteArray(String, byte[])} automatically
+     * supplying an empty byte[] as default value.
+     * 
+     * @param id
+     * @return prop values as array
+     */
+    public byte[] getByteArray(String id) {
+        return getByteArray(id, new byte[0]);
+    }
+
+    /**
+     * Returns a comma delimited property value as byte[] array. Non-byte values
+     * will be ignored.
+     * 
+     * @param id
+     *            prop name
+     * @param defaultArray
+     * @return prop values as array
+     */
+    public byte[] getByteArray(String id, byte[] defaultArray) {
+        StringTokenizer tokenizer = new StringTokenizer(getProperty(id, ""),
+                DELIM);
+        byte[] pieces = new byte[tokenizer.countTokens()];
+        int index = 0;
+        while (tokenizer.hasMoreTokens()) {
+            try {
+                pieces[index] = Byte.parseByte(tokenizer.nextToken());
+                index++;
+            } catch (NumberFormatException e) {
+                // ignore non-integer items
+            }
+        }
+        if (index > 0) {
+            byte[] result = new byte[index];
+            System.arraycopy(pieces, 0, result, 0, index);
+            return result;
+        } else {
+            return defaultArray;
+        }
+    }
+
+    /**
+     * Returns a property as float.
+     * 
+     * @param id
+     * @param defaultValue
+     * @return prop value
+     */
+    public float getFloat(String id, float defaultValue) {
+        return Float.parseFloat(getProperty(id, "" + defaultValue));
+    }
+
+    /**
+     * Shorthand wrapper for {@link #getFloatArray(String, float[])}
+     * automatically supplying an empty float[] array as default value.
+     * 
+     * @param id
+     * @return prop values as array
+     */
+    public float[] getFloatArray(String id) {
+        return getFloatArray(id, new float[0]);
+    }
+
+    /**
+     * Returns a comma delimited property value as float[] array.
+     * 
+     * @param id
+     *            prop name
+     * @param defaultArray
+     * @return prop items as array
+     */
+    public float[] getFloatArray(String id, float[] defaultArray) {
+        StringTokenizer tokenizer = new StringTokenizer(getProperty(id, ""),
+                DELIM);
+        float pieces[] = new float[tokenizer.countTokens()];
+        int index = 0;
+        while (tokenizer.hasMoreTokens()) {
+            try {
+                pieces[index] = Float.parseFloat(tokenizer.nextToken());
+                index++;
+            } catch (NumberFormatException e) {
+                // ignore NaN items
+            }
+        }
+        if (index > 0) {
+            float[] result = new float[index];
+            System.arraycopy(pieces, 0, result, 0, index);
+            return result;
+        } else {
+            return defaultArray;
+        }
+    }
+
+    /**
+     * Returns a hexadecimal property as integer
+     * 
+     * @param id
+     *            prop name
+     * @param defaultValue
+     * @return prop value
+     */
+    public int getHexInt(String id, int defaultValue) {
+        return Integer.parseInt(
+                getProperty(id, Integer.toHexString(defaultValue)), 16);
+    }
+
+    /**
+     * Returns a property as integer.
+     * 
+     * @param id
+     *            property name
+     * @param defaultValue
+     * @return prop value
+     */
+    public int getInt(String id, int defaultValue) {
+        return Integer.parseInt(getProperty(id, "" + defaultValue));
+    }
+
+    /**
+     * Shorthand wrapper for {{@link #getIntArray(String, int[])} automatically
+     * supplying an empty int[] array as default value.
+     * 
+     * @param id
+     * @return prop values as array
+     */
+    public int[] getIntArray(String id) {
+        return getIntArray(id, new int[0]);
+    }
+
+    /**
+     * Returns a comma delimited property value as int[] array. Non-integer
+     * items will be ignored.
+     * 
+     * @param id
+     *            prop name
+     * @param defaultArray
+     * @return prop items as array
+     */
+    public int[] getIntArray(String id, int[] defaultArray) {
+        StringTokenizer tokenizer = new StringTokenizer(getProperty(id, ""),
+                DELIM);
+        int pieces[] = new int[tokenizer.countTokens()];
+        int index = 0;
+        while (tokenizer.hasMoreTokens()) {
+            try {
+                pieces[index] = Integer.parseInt(tokenizer.nextToken());
+                index++;
+            } catch (NumberFormatException e) {
+                // ignore non-integer items
+            }
+        }
+        if (index > 0) {
+            int[] result = new int[index];
+            System.arraycopy(pieces, 0, result, 0, index);
+            return result;
+        } else {
+            return defaultArray;
+        }
+    }
+
+    /**
+     *
+     * @param id
+     * @return
+     */
+    public String[] getStringArray(String id) {
+        return getStringArray(id, new String[0]);
+    }
+
+    /**
+     *
+     * @param id
+     * @param defaultArray
+     * @return
+     */
+    public String[] getStringArray(String id, String[] defaultArray) {
+        StringTokenizer tokenizer = new StringTokenizer(getProperty(id, ""),
+                DELIM);
+        int index = 0;
+        String[] pieces = null;
+        while (tokenizer.hasMoreTokens()) {
+            if (pieces == null) {
+                pieces = new String[tokenizer.countTokens()];
+            }
+            String token = tokenizer.nextToken();
+            if (token.length() > 0) {
+                pieces[index++] = token;
+            }
+        }
+        if (index > 0) {
+            String[] result = new String[index];
+            System.arraycopy(pieces, 0, result, 0, index);
+            return result;
+        } else {
+            return defaultArray;
+        }
+    }
+
+    /**
+     * Attempts to load properties from the specified (absolute) file path (In
+     * Processing use sketchPath() or dataPath() to build absolute path).
+     * 
+     * @param path
+     *            config file
+     * @return true, if successful.
+     */
+    public boolean load(String path) {
+        try {
+            load(new FileInputStream(path));
+            return true;
+        } catch (Exception e) {
+            logger.log(Level.WARNING, "error opening config file: {0}", path);
+            return false;
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public HashMap<String, String> toHashMap() {
+        HashMap<String, String> map = new HashMap<>();
+        for (String id : stringPropertyNames()) {
+            map.put(id, getProperty(id));
+        }
+        return map;
+    }
+}

data/src/toxi/util/datatypes/UndirectedGraph.java

@@ -0,0 +1,134 @@
+package toxi.util.datatypes;
+
+/*
+ * Copyright (c) 2007 by L. Paul Chew.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Straightforward undirected graph implementation. Nodes are generic type N.
+ * 
+ * @author Paul Chew Created November, December 2007. For use in
+ *         Delaunay/Voronoi code.
+ * @author toxi Updated July 2010, minor API changes to be better suited for
+ *         toxiclibs
+ * @param <N>
+ */
+public class UndirectedGraph<N> {
+
+    /**
+     *
+     */
+    protected Map<N, Set<N>> nodeLinks = new HashMap<>();
+
+    /**
+     *
+     */
+    protected Set<N> nodeIDs = Collections.unmodifiableSet(nodeLinks.keySet());
+
+    /**
+     * Add a node. If node is already in graph then no change.
+     * 
+     * @param node
+     *            the node to add
+     */
+    public void add(N node) {
+        if (nodeLinks.containsKey(node)) {
+            return;
+        }
+        nodeLinks.put(node, new ArraySet<N>());
+    }
+
+    /**
+     * Add a link. If the link is already in graph then no change.
+     * 
+     * @param nodeA
+     *            one end of the link
+     * @param nodeB
+     *            the other end of the link
+     * @throws NullPointerException
+     *             if either endpoint is not in graph
+     */
+    public void connect(N nodeA, N nodeB) throws NullPointerException {
+        nodeLinks.get(nodeA).add(nodeB);
+        nodeLinks.get(nodeB).add(nodeA);
+    }
+
+    /**
+     * Remove the specified link. If link not in graph, nothing happens.
+     * 
+     * @param nodeA
+     *            one end of the link
+     * @param nodeB
+     *            the other end of the link
+     * @throws NullPointerException
+     *             if either endpoint is not in graph
+     */
+    public void disconnect(N nodeA, N nodeB) throws NullPointerException {
+        nodeLinks.get(nodeA).remove(nodeB);
+        nodeLinks.get(nodeB).remove(nodeA);
+    }
+
+    /**
+     * Report all the neighbors of node.
+     * 
+     * @param node
+     *            the node
+     * @return the neighbors of node
+     * @throws NullPointerException
+     *             if node does not appear in graph
+     */
+    public Set<N> getConnectedNodesFor(N node) throws NullPointerException {
+        return Collections.unmodifiableSet(nodeLinks.get(node));
+    }
+
+    /**
+     * Returns an unmodifiable Set view of the nodes contained in this graph.
+     * The set is backed by the graph, so changes to the graph are reflected in
+     * the set.
+     * 
+     * @return a Set view of the graph's node set
+     */
+    public Set<N> getNodes() {
+        return nodeIDs;
+    }
+
+    /**
+     * Remove node and any links that use node. If node not in graph, nothing
+     * happens.
+     * 
+     * @param node
+     *            the node to remove.
+     */
+    public void remove(N node) {
+        if (!nodeLinks.containsKey(node)) {
+            return;
+        }
+        for (N neighbor : nodeLinks.get(node)) {
+            nodeLinks.get(neighbor).remove(node);
+        }
+        nodeLinks.get(node).clear();
+        nodeLinks.remove(node);
+    }
+
+}