toxiclibs 0.4.0 → 0.8.0

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

@@ -0,0 +1,223 @@
+package toxi.util.datatypes;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * This class is used to build an unique set of items and offers a
+ * bi-directional mapping between items and their associated ID values. Items
+ * are added via the {@link #index(Object)} method and removed via
+ * {@link #unindex(Object)}. The item's {@link #hashCode()} is used as unique
+ * identifier, so you MUST ensure the item class satisfies the contract of
+ * {@link #hashCode()} and {@link #equals(Object)}.
+ * @param <T>
+ */
+public class UniqueItemIndex<T> implements ItemIndex<T> {
+
+    /**
+     *
+     */
+    protected final HashMap<T, Integer> uniqueItems = new HashMap<>();
+
+    /**
+     *
+     */
+    protected final ArrayList<T> index = new ArrayList<>();
+
+    /**
+     *
+     */
+    public UniqueItemIndex() {
+    }
+
+    /**
+     *
+     * @param items
+     */
+    public UniqueItemIndex(Collection<T> items) {
+        for (T item : items) {
+            index(item);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#clear()
+     */
+
+    /**
+     *
+     */
+    @Override
+    public void clear() {
+        uniqueItems.clear();
+        index.clear();
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#forID(int)
+     */
+
+    /**
+     *
+     * @param id
+     * @return
+     */
+    
+    @Override
+    public T forID(int id) {
+        return index.get(id);
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#getID(T)
+     */
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    
+    @Override
+    public int getID(T item) {
+        Integer id = uniqueItems.get(item);
+        return (id != null) ? id : -1;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#getItems()
+     */
+
+    /**
+     *
+     * @return
+     */
+    
+    @Override
+    public List<T> getItems() {
+        return index;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#index(T)
+     */
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    
+    @Override
+    public int index(T item) {
+        Integer id = uniqueItems.get(item);
+        if (id == null) {
+            id = index.size();
+            uniqueItems.put(item, id);
+            index.add(item);
+        }
+        return id;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#isIndexed(T)
+     */
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    
+    @Override
+    public boolean isIndexed(T item) {
+        return uniqueItems.get(item) != null;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#reindex(T, T)
+     */
+
+    /**
+     *
+     * @param item
+     * @param newItem
+     * @return
+     */
+    
+    @Override
+    public int reindex(T item, T newItem) {
+        int id = getID(item);
+        if (id != -1) {
+            int newID = getID(newItem);
+            if (newID != -1) {
+                unindex(item);
+                id = getID(newItem);
+            } else {
+                index.set(id, newItem);
+                uniqueItems.remove(item);
+                uniqueItems.put(newItem, id);
+            }
+        }
+        return id;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#size()
+     */
+
+    /**
+     *
+     * @return
+     */
+    
+    @Override
+    public int size() {
+        return index.size();
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.util.ItemIndex#unindex(T)
+     */
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    
+    @Override
+    public int unindex(T item) {
+        Integer id = uniqueItems.get(item);
+        if (id != null) {
+            uniqueItems.remove(item);
+            index.remove(item);
+            for (int i = id, num = index.size(); i < num; i++) {
+                uniqueItems.put(index.get(i), i);
+            }
+        } else {
+            id = -1;
+        }
+        return id;
+    }
+}

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

@@ -0,0 +1,76 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * This class encapsulates a single element within a {@link WeightedRandomSet}.
+ * 
+ * @param <T>
+ */
+public class WeightedRandomEntry<T> implements
+        Comparable<WeightedRandomEntry<T>> {
+
+    /**
+     *
+     */
+    protected T item;
+
+    /**
+     *
+     */
+    protected int weight;
+
+    /**
+     *
+     * @param item
+     * @param weight
+     */
+    public WeightedRandomEntry(T item, int weight) {
+        this.item = item;
+        this.weight = weight;
+    }
+
+    /**
+     *
+     * @param e
+     * @return
+     */
+    @Override
+    public int compareTo(WeightedRandomEntry<T> e) {
+        return (e.weight - weight);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return item.toString() + ": " + weight;
+    }
+}

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

@@ -0,0 +1,125 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.ArrayList;
+import java.util.List;
+
+import toxi.math.MathUtils;
+
+/**
+ * This class provides a generic random-weight distribution of arbitary objects.
+ * Add elements with their weight to the set and then use the
+ * {@link #getRandom()} method to retrieve objects. The frequency of returned
+ * elements is based on their relative weight. This makes it easy to provide
+ * biased preferences.
+ * 
+ * http://www.electricmonk.nl/log/2009/12/23/weighted-random-distribution/
+ * @param <T>
+ */
+public class WeightedRandomSet<T> {
+
+    /**
+     *
+     */
+    protected List<WeightedRandomEntry<T>> elements = new ArrayList<>();
+
+    /**
+     *
+     */
+    protected int totalWeight;
+
+    /**
+     * Add a new element of type T to the set.
+     * 
+     * @param item
+     * @param weight
+     * @return itself
+     */
+    public WeightedRandomSet<T> add(T item, int weight) {
+        WeightedRandomEntry<T> e = new WeightedRandomEntry<>(item, weight);
+        int num = elements.size();
+        boolean isInserted = false;
+        if (num > 0) {
+            for (int i = 0; i < num; i++) {
+                if (weight < elements.get(i).weight) {
+                    elements.add(i, e);
+                    isInserted = true;
+                    break;
+                }
+            }
+        }
+        if (!isInserted) {
+            elements.add(e);
+        }
+        totalWeight += weight;
+        return this;
+    }
+
+    /**
+     * @return the elements
+     */
+    public List<WeightedRandomEntry<T>> getElements() {
+        return elements;
+    }
+
+    /**
+     * Returns a randomly picked element from the set. The frequency of
+     * occurance depends on the relative weight of each item.
+     * 
+     * @return picked element
+     */
+    public T getRandom() {
+        int rnd = MathUtils.random(totalWeight);
+        T choice = null;
+        int sum = totalWeight;
+        for (WeightedRandomEntry<T> e : elements) {
+            sum -= e.weight;
+            if (sum <= rnd) {
+                choice = e.item;
+                break;
+            }
+        }
+        return choice;
+    }
+
+    /**
+     * Removes the given item from the set.
+     * 
+     * @param item
+     */
+    public void remove(T item) {
+        for (WeightedRandomEntry<T> e : elements) {
+            if (e.item.equals(item)) {
+                elements.remove(e);
+                totalWeight -= e.weight;
+                return;
+            }
+        }
+    }
+}

data/src/toxi/util/events/EventDispatcher.java

@@ -0,0 +1,86 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.events;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ *
+ * @author tux
+ * @param <T>
+ */
+public class EventDispatcher<T> implements Iterable<T> {
+
+    /**
+     *
+     */
+    protected List<T> listeners = new LinkedList<>();
+
+    /**
+     *
+     */
+    public EventDispatcher() {
+    }
+
+    /**
+     *
+     * @param listener
+     */
+    public void addListener(T listener) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener);
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<T> getListeners() {
+        return listeners;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public Iterator<T> iterator() {
+        return listeners.iterator();
+    }
+
+    /**
+     *
+     * @param listener
+     */
+    public void removeListener(T listener) {
+        listeners.remove(listener);
+    }
+}