propane 3.6.0-java → 3.10.0-java

data/lib/java/processing/data/JSONTokener.java

@@ -0,0 +1,435 @@
+package processing.data;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StringReader;
+
+/*
+Copyright (c) 2002 JSON.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, 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 shall be used for Good, not Evil.
+
+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.
+ */
+
+/**
+ * A JSONTokener takes a source string and extracts characters and tokens from
+ * it. It is used by the JSONObject and JSONArray constructors to parse
+ * JSON source strings.
+ * @author JSON.org
+ * @version 2012-02-16
+ */
+class JSONTokener {
+
+  private long    character;
+  private boolean eof;
+  private long    index;
+  private long    line;
+  private char    previous;
+  private Reader  reader;
+  private boolean usePrevious;
+
+
+  /**
+   * Construct a JSONTokener from a Reader.
+   *
+   * @param reader     A reader.
+   */
+  public JSONTokener(Reader reader) {
+    this.reader = reader.markSupported()
+      ? reader
+        : new BufferedReader(reader);
+    this.eof = false;
+    this.usePrevious = false;
+    this.previous = 0;
+    this.index = 0;
+    this.character = 1;
+    this.line = 1;
+  }
+
+
+  /**
+   * Construct a JSONTokener from an InputStream.
+   */
+  public JSONTokener(InputStream inputStream) {
+    this(new InputStreamReader(inputStream));
+  }
+
+
+  /**
+   * Construct a JSONTokener from a string.
+   *
+   * @param s     A source string.
+   */
+  public JSONTokener(String s) {
+    this(new StringReader(s));
+  }
+
+
+  /**
+   * Back up one character. This provides a sort of lookahead capability,
+   * so that you can test for a digit or letter before attempting to parse
+   * the next number or identifier.
+   */
+  public void back() {
+    if (this.usePrevious || this.index <= 0) {
+      throw new RuntimeException("Stepping back two steps is not supported");
+    }
+    this.index -= 1;
+    this.character -= 1;
+    this.usePrevious = true;
+    this.eof = false;
+  }
+
+
+  /**
+   * Get the hex value of a character (base16).
+   * @param c A character between '0' and '9' or between 'A' and 'F' or
+   * between 'a' and 'f'.
+   * @return  An int between 0 and 15, or -1 if c was not a hex digit.
+   */
+  public static int dehexchar(char c) {
+    if (c >= '0' && c <= '9') {
+      return c - '0';
+    }
+    if (c >= 'A' && c <= 'F') {
+      return c - ('A' - 10);
+    }
+    if (c >= 'a' && c <= 'f') {
+      return c - ('a' - 10);
+    }
+    return -1;
+  }
+
+  public boolean end() {
+    return this.eof && !this.usePrevious;
+  }
+
+
+  /**
+   * Determine if the source string still contains characters that next()
+   * can consume.
+   * @return true if not yet at the end of the source.
+   */
+  public boolean more() {
+    this.next();
+    if (this.end()) {
+      return false;
+    }
+    this.back();
+    return true;
+  }
+
+
+  /**
+   * Get the next character in the source string.
+   *
+   * @return The next character, or 0 if past the end of the source string.
+   */
+  public char next() {
+    int c;
+    if (this.usePrevious) {
+      this.usePrevious = false;
+      c = this.previous;
+    } else {
+      try {
+        c = this.reader.read();
+      } catch (IOException exception) {
+        throw new RuntimeException(exception);
+      }
+
+      if (c <= 0) { // End of stream
+        this.eof = true;
+      c = 0;
+      }
+    }
+    this.index += 1;
+    if (this.previous == '\r') {
+      this.line += 1;
+      this.character = c == '\n' ? 0 : 1;
+    } else if (c == '\n') {
+      this.line += 1;
+      this.character = 0;
+    } else {
+      this.character += 1;
+    }
+    this.previous = (char) c;
+    return this.previous;
+  }
+
+
+  /**
+   * Consume the next character, and check that it matches a specified
+   * character.
+   * @param c The character to match.
+   * @return The character.
+   * @throws JSONException if the character does not match.
+   */
+  public char next(char c) {
+    char n = this.next();
+    if (n != c) {
+      throw new RuntimeException("Expected '" + c + "' and instead saw '" + n + "'");
+    }
+    return n;
+  }
+
+
+  /**
+   * Get the next n characters.
+   *
+   * @param n     The number of characters to take.
+   * @return      A string of n characters.
+   * @throws JSONException
+   *   Substring bounds error if there are not
+   *   n characters remaining in the source string.
+   */
+  public String next(int n) {
+    if (n == 0) {
+      return "";
+    }
+
+    char[] chars = new char[n];
+    int pos = 0;
+
+    while (pos < n) {
+      chars[pos] = this.next();
+      if (this.end()) {
+        throw new RuntimeException("Substring bounds error");
+      }
+      pos += 1;
+    }
+    return new String(chars);
+  }
+
+
+  /**
+   * Get the next char in the string, skipping whitespace.
+   * @throws JSONException
+   * @return  A character, or 0 if there are no more characters.
+   */
+  public char nextClean() {
+    for (;;) {
+      char c = this.next();
+      if (c == 0 || c > ' ') {
+        return c;
+      }
+    }
+  }
+
+
+  /**
+   * Return the characters up to the next close quote character.
+   * Backslash processing is done. The formal JSON format does not
+   * allow strings in single quotes, but an implementation is allowed to
+   * accept them.
+   * @param quote The quoting character, either
+   *      <code>"</code>&nbsp;<small>(double quote)</small> or
+   *      <code>'</code>&nbsp;<small>(single quote)</small>.
+   * @return      A String.
+   * @throws JSONException Unterminated string.
+   */
+  public String nextString(char quote) {
+    char c;
+    StringBuilder sb = new StringBuilder();
+    for (;;) {
+      c = this.next();
+      switch (c) {
+      case 0:
+      case '\n':
+      case '\r':
+        throw new RuntimeException("Unterminated string");
+      case '\\':
+        c = this.next();
+        switch (c) {
+        case 'b':
+          sb.append('\b');
+          break;
+        case 't':
+          sb.append('\t');
+          break;
+        case 'n':
+          sb.append('\n');
+          break;
+        case 'f':
+          sb.append('\f');
+          break;
+        case 'r':
+          sb.append('\r');
+          break;
+        case 'u':
+          sb.append((char)Integer.parseInt(this.next(4), 16));
+          break;
+        case '"':
+        case '\'':
+        case '\\':
+        case '/':
+          sb.append(c);
+          break;
+        default:
+          throw new RuntimeException("Illegal escape.");
+        }
+        break;
+      default:
+        if (c == quote) {
+          return sb.toString();
+        }
+        sb.append(c);
+      }
+    }
+  }
+
+
+  /**
+   * Get the text up but not including the specified character or the
+   * end of line, whichever comes first.
+   * @param  delimiter A delimiter character.
+   * @return   A string.
+   */
+  public String nextTo(char delimiter) {
+    StringBuilder sb = new StringBuilder();
+    for (;;) {
+      char c = this.next();
+      if (c == delimiter || c == 0 || c == '\n' || c == '\r') {
+        if (c != 0) {
+          this.back();
+        }
+        return sb.toString().trim();
+      }
+      sb.append(c);
+    }
+  }
+
+
+  /**
+   * Get the text up but not including one of the specified delimiter
+   * characters or the end of line, whichever comes first.
+   * @param delimiters A set of delimiter characters.
+   * @return A string, trimmed.
+   */
+  public String nextTo(String delimiters) {
+    char c;
+    StringBuilder sb = new StringBuilder();
+    for (;;) {
+      c = this.next();
+      if (delimiters.indexOf(c) >= 0 || c == 0 ||
+        c == '\n' || c == '\r') {
+        if (c != 0) {
+          this.back();
+        }
+        return sb.toString().trim();
+      }
+      sb.append(c);
+    }
+  }
+
+
+  /**
+   * Get the next value. The value can be a Boolean, Double, Integer,
+   * JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object.
+   * @throws JSONException If syntax error.
+   *
+   * @return An object.
+   */
+  public Object nextValue() {
+    char c = this.nextClean();
+    String string;
+
+    switch (c) {
+    case '"':
+    case '\'':
+      return this.nextString(c);
+    case '{':
+      this.back();
+      return new JSONObject(this);
+    case '[':
+      this.back();
+      return new JSONArray(this);
+    }
+
+    /*
+     * Handle unquoted text. This could be the values true, false, or
+     * null, or it can be a number. An implementation (such as this one)
+     * is allowed to also accept non-standard forms.
+     *
+     * Accumulate characters until we reach the end of the text or a
+     * formatting character.
+     */
+
+    StringBuilder sb = new StringBuilder();
+    while (c >= ' ' && ",:]}/\\\"[{;=#".indexOf(c) < 0) {
+      sb.append(c);
+      c = this.next();
+    }
+    this.back();
+
+    string = sb.toString().trim();
+    if ("".equals(string)) {
+      throw new RuntimeException("Missing value");
+    }
+    return JSONObject.stringToValue(string);
+  }
+
+
+  /**
+   * Skip characters until the next character is the requested character.
+   * If the requested character is not found, no characters are skipped.
+   * @param to A character to skip to.
+   * @return The requested character, or zero if the requested character
+   * is not found.
+   */
+  public char skipTo(char to) {
+    char c;
+    try {
+      long startIndex = this.index;
+      long startCharacter = this.character;
+      long startLine = this.line;
+      this.reader.mark(1000000);
+      do {
+        c = this.next();
+        if (c == 0) {
+          this.reader.reset();
+          this.index = startIndex;
+          this.character = startCharacter;
+          this.line = startLine;
+          return c;
+        }
+      } while (c != to);
+    } catch (IOException exc) {
+      throw new RuntimeException(exc);
+    }
+
+    this.back();
+    return c;
+  }
+
+
+  /**
+   * Make a printable string of this JSONTokener.
+   *
+   * @return " at {index} [character {character} line {line}]"
+   */
+  @Override
+  public String toString() {
+    return " at " + this.index + " [character " + this.character + " line " +
+      this.line + "]";
+  }
+}

data/lib/java/processing/data/LongDict.java

@@ -0,0 +1,802 @@
+package processing.data;
+
+import java.io.*;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import processing.core.PApplet;
+
+
+/**
+ * A simple class to use a String as a lookup for an int value.
+ *
+ * @nowebref
+ * @see FloatDict
+ * @see StringDict
+ */
+public class LongDict {
+
+  /** Number of elements in the table */
+  protected int count;
+
+  protected String[] keys;
+  protected long[] values;
+
+  /** Internal implementation for faster lookups */
+  private HashMap<String, Integer> indices = new HashMap<>();
+
+
+  public LongDict() {
+    count = 0;
+    keys = new String[10];
+    values = new long[10];
+  }
+
+
+  /**
+   * Create a new lookup with a specific size. This is more efficient than not
+   * specifying a size. Use it when you know the rough size of the thing you're creating.
+   *
+   * @nowebref
+   */
+  public LongDict(int length) {
+    count = 0;
+    keys = new String[length];
+    values = new long[length];
+  }
+
+
+  /**
+   * Read a set of entries from a Reader that has each key/value pair on
+   * a single line, separated by a tab.
+   *
+   * @nowebref
+   */
+  public LongDict(BufferedReader reader) {
+    String[] lines = PApplet.loadStrings(reader);
+    keys = new String[lines.length];
+    values = new long[lines.length];
+
+    for (int i = 0; i < lines.length; i++) {
+      String[] pieces = PApplet.split(lines[i], '\t');
+      if (pieces.length == 2) {
+        keys[count] = pieces[0];
+        values[count] = PApplet.parseInt(pieces[1]);
+        indices.put(pieces[0], count);
+        count++;
+      }
+    }
+  }
+
+  /**
+   * @nowebref
+   */
+  public LongDict(String[] keys, long[] values) {
+    if (keys.length != values.length) {
+      throw new IllegalArgumentException("key and value arrays must be the same length");
+    }
+    this.keys = keys;
+    this.values = values;
+    count = keys.length;
+    for (int i = 0; i < count; i++) {
+      indices.put(keys[i], i);
+    }
+  }
+
+
+  /**
+   * Constructor to allow (more intuitive) inline initialization, e.g.:
+   * <pre>
+   * new FloatDict(new Object[][] {
+   *   { "key1", 1 },
+   *   { "key2", 2 }
+   * });
+   * </pre>
+   */
+  public LongDict(Object[][] pairs) {
+    count = pairs.length;
+    this.keys = new String[count];
+    this.values = new long[count];
+    for (int i = 0; i < count; i++) {
+      keys[i] = (String) pairs[i][0];
+      values[i] = (Integer) pairs[i][1];
+      indices.put(keys[i], i);
+    }
+  }
+
+
+  /**
+   * Returns the number of key/value pairs
+   *
+   * @webref intdict:method
+   * @brief Returns the number of key/value pairs
+   */
+  public int size() {
+    return count;
+  }
+
+
+  /**
+   * Resize the internal data, this can only be used to shrink the list.
+   * Helpful for situations like sorting and then grabbing the top 50 entries.
+   */
+  public void resize(int length) {
+    if (length > count) {
+      throw new IllegalArgumentException("resize() can only be used to shrink the dictionary");
+    }
+    if (length < 1) {
+      throw new IllegalArgumentException("resize(" + length + ") is too small, use 1 or higher");
+    }
+
+    String[] newKeys = new String[length];
+    long[] newValues = new long[length];
+    PApplet.arrayCopy(keys, newKeys, length);
+    PApplet.arrayCopy(values, newValues, length);
+    keys = newKeys;
+    values = newValues;
+    count = length;
+    resetIndices();
+  }
+
+
+  /**
+   * Remove all entries.
+   *
+   * @webref intdict:method
+   * @brief Remove all entries
+   */
+  public void clear() {
+    count = 0;
+    indices = new HashMap<>();
+  }
+
+
+  private void resetIndices() {
+    indices = new HashMap<>(count);
+    for (int i = 0; i < count; i++) {
+      indices.put(keys[i], i);
+    }
+  }
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+
+  public class Entry {
+    public String key;
+    public long value;
+
+    Entry(String key, long value) {
+      this.key = key;
+      this.value = value;
+    }
+  }
+
+
+  public Iterable<Entry> entries() {
+    return new Iterable<Entry>() {
+
+      public Iterator<Entry> iterator() {
+        return entryIterator();
+      }
+    };
+  }
+
+
+  public Iterator<Entry> entryIterator() {
+    return new Iterator<Entry>() {
+      int index = -1;
+
+      public void remove() {
+        removeIndex(index);
+        index--;
+      }
+
+      public Entry next() {
+        ++index;
+        Entry e = new Entry(keys[index], values[index]);
+        return e;
+      }
+
+      public boolean hasNext() {
+        return index+1 < size();
+      }
+    };
+  }
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+
+  public String key(int index) {
+    return keys[index];
+  }
+
+
+  protected void crop() {
+    if (count != keys.length) {
+      keys = PApplet.subset(keys, 0, count);
+      values = PApplet.subset(values, 0, count);
+    }
+  }
+
+
+  public Iterable<String> keys() {
+    return new Iterable<String>() {
+
+      @Override
+      public Iterator<String> iterator() {
+        return keyIterator();
+      }
+    };
+  }
+
+
+  // Use this to iterate when you want to be able to remove elements along the way
+  public Iterator<String> keyIterator() {
+    return new Iterator<String>() {
+      int index = -1;
+
+      public void remove() {
+        removeIndex(index);
+        index--;
+      }
+
+      public String next() {
+        return key(++index);
+      }
+
+      public boolean hasNext() {
+        return index+1 < size();
+      }
+    };
+  }
+
+
+  /**
+   * Return a copy of the internal keys array. This array can be modified.
+   *
+   * @webref intdict:method
+   * @brief Return a copy of the internal keys array
+   */
+  public String[] keyArray() {
+    crop();
+    return keyArray(null);
+  }
+
+
+  public String[] keyArray(String[] outgoing) {
+    if (outgoing == null || outgoing.length != count) {
+      outgoing = new String[count];
+    }
+    System.arraycopy(keys, 0, outgoing, 0, count);
+    return outgoing;
+  }
+
+
+  public long value(int index) {
+    return values[index];
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Return the internal array being used to store the values
+   */
+  public Iterable<Long> values() {
+    return new Iterable<Long>() {
+
+      @Override
+      public Iterator<Long> iterator() {
+        return valueIterator();
+      }
+    };
+  }
+
+
+  public Iterator<Long> valueIterator() {
+    return new Iterator<Long>() {
+      int index = -1;
+
+      public void remove() {
+        removeIndex(index);
+        index--;
+      }
+
+      public Long next() {
+        return value(++index);
+      }
+
+      public boolean hasNext() {
+        return index+1 < size();
+      }
+    };
+  }
+
+
+  /**
+   * Create a new array and copy each of the values into it.
+   *
+   * @webref intdict:method
+   * @brief Create a new array and copy each of the values into it
+   */
+  public int[] valueArray() {
+    crop();
+    return valueArray(null);
+  }
+
+
+  /**
+   * Fill an already-allocated array with the values (more efficient than
+   * creating a new array each time). If 'array' is null, or not the same
+   * size as the number of values, a new array will be allocated and returned.
+   *
+   * @param array values to copy into the array
+   */
+  public int[] valueArray(int[] array) {
+    if (array == null || array.length != size()) {
+      array = new int[count];
+    }
+    System.arraycopy(values, 0, array, 0, count);
+    return array;
+  }
+
+
+  /**
+   * Return a value for the specified key.
+   *
+   * @webref intdict:method
+   * @brief Return a value for the specified key
+   */
+  public long get(String key) {
+    int index = index(key);
+    if (index == -1) {
+      throw new IllegalArgumentException("No key named '" + key + "'");
+    }
+    return values[index];
+  }
+
+
+  public long get(String key, long alternate) {
+    int index = index(key);
+    if (index == -1) return alternate;
+    return values[index];
+  }
+
+
+  /**
+   * Create a new key/value pair or change the value of one.
+   *
+   * @webref intdict:method
+   * @brief Create a new key/value pair or change the value of one
+   */
+  public void set(String key, long amount) {
+    int index = index(key);
+    if (index == -1) {
+      create(key, amount);
+    } else {
+      values[index] = amount;
+    }
+  }
+
+
+  public void setIndex(int index, String key, long value) {
+    if (index < 0 || index >= count) {
+      throw new ArrayIndexOutOfBoundsException(index);
+    }
+    keys[index] = key;
+    values[index] = value;
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Check if a key is a part of the data structure
+   */
+  public boolean hasKey(String key) {
+    return index(key) != -1;
+  }
+
+
+  /**
+   * Increase the value associated with a specific key by 1.
+   *
+   * @webref intdict:method
+   * @brief Increase the value of a specific key value by 1
+   */
+  public void increment(String key) {
+    add(key, 1);
+  }
+
+
+  /**
+   * Merge another dictionary into this one. Calling this increment()
+   * since it doesn't make sense in practice for the other dictionary types,
+   * even though it's technically an add().
+   */
+  public void increment(LongDict dict) {
+    for (int i = 0; i < dict.count; i++) {
+      add(dict.key(i), dict.value(i));
+    }
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Add to a value
+   */
+  public void add(String key, long amount) {
+    int index = index(key);
+    if (index == -1) {
+      create(key, amount);
+    } else {
+      values[index] += amount;
+    }
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Subtract from a value
+   */
+  public void sub(String key, long amount) {
+    add(key, -amount);
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Multiply a value
+   */
+  public void mult(String key, long amount) {
+    int index = index(key);
+    if (index != -1) {
+      values[index] *= amount;
+    }
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Divide a value
+   */
+  public void div(String key, long amount) {
+    int index = index(key);
+    if (index != -1) {
+      values[index] /= amount;
+    }
+  }
+
+
+  private void checkMinMax(String functionName) {
+    if (count == 0) {
+      String msg =
+        String.format("Cannot use %s() on an empty %s.",
+                      functionName, getClass().getSimpleName());
+      throw new RuntimeException(msg);
+    }
+  }
+
+
+  // return the index of the minimum value
+  public int minIndex() {
+    //checkMinMax("minIndex");
+    if (count == 0) return -1;
+
+    int index = 0;
+    long value = values[0];
+    for (int i = 1; i < count; i++) {
+      if (values[i] < value) {
+        index = i;
+        value = values[i];
+      }
+    }
+    return index;
+  }
+
+
+  // return the key for the minimum value
+  public String minKey() {
+    checkMinMax("minKey");
+    int index = minIndex();
+    if (index == -1) {
+      return null;
+    }
+    return keys[index];
+  }
+
+
+  // return the minimum value, or throw an error if there are no values
+  public long minValue() {
+    checkMinMax("minValue");
+    return values[minIndex()];
+  }
+
+
+  // return the index of the max value
+  public int maxIndex() {
+    //checkMinMax("maxIndex");
+    if (count == 0) {
+      return -1;
+    }
+    int index = 0;
+    long value = values[0];
+    for (int i = 1; i < count; i++) {
+      if (values[i] > value) {
+        index = i;
+        value = values[i];
+      }
+    }
+    return index;
+  }
+
+
+  /** return the key corresponding to the maximum value or null if no entries */
+  public String maxKey() {
+    //checkMinMax("maxKey");
+    int index = maxIndex();
+    if (index == -1) {
+      return null;
+    }
+    return keys[index];
+  }
+
+
+  // return the maximum value or throw an error if zero length
+  public long maxValue() {
+    checkMinMax("maxIndex");
+    return values[maxIndex()];
+  }
+
+
+  public long sum() {
+    long sum = 0;
+    for (int i = 0; i < count; i++) {
+      sum += values[i];
+    }
+    return sum;
+  }
+
+
+  public int index(String what) {
+    Integer found = indices.get(what);
+    return (found == null) ? -1 : found.intValue();
+  }
+
+
+  protected void create(String what, long much) {
+    if (count == keys.length) {
+      keys = PApplet.expand(keys);
+      values = PApplet.expand(values);
+    }
+    indices.put(what, Integer.valueOf(count));
+    keys[count] = what;
+    values[count] = much;
+    count++;
+  }
+
+
+  /**
+   * @webref intdict:method
+   * @brief Remove a key/value pair
+   */
+  public long remove(String key) {
+    int index = index(key);
+    if (index == -1) {
+      throw new NoSuchElementException("'" + key + "' not found");
+    }
+    long value = values[index];
+    removeIndex(index);
+    return value;
+  }
+
+
+  public long removeIndex(int index) {
+    if (index < 0 || index >= count) {
+      throw new ArrayIndexOutOfBoundsException(index);
+    }
+    long value = values[index];
+    indices.remove(keys[index]);
+    for (int i = index; i < count-1; i++) {
+      keys[i] = keys[i+1];
+      values[i] = values[i+1];
+      indices.put(keys[i], i);
+    }
+    count--;
+    keys[count] = null;
+    values[count] = 0;
+    return value;
+  }
+
+
+  public void swap(int a, int b) {
+    String tkey = keys[a];
+    long tvalue = values[a];
+    keys[a] = keys[b];
+    values[a] = values[b];
+    keys[b] = tkey;
+    values[b] = tvalue;
+
+//    indices.put(keys[a], Integer.valueOf(a));
+//    indices.put(keys[b], Integer.valueOf(b));
+  }
+
+
+  /**
+   * Sort the keys alphabetically (ignoring case). Uses the value as a
+   * tie-breaker (only really possible with a key that has a case change).
+   *
+   * @webref intdict:method
+   * @brief Sort the keys alphabetically
+   */
+  public void sortKeys() {
+    sortImpl(true, false, true);
+  }
+
+  /**
+   * Sort the keys alphabetically in reverse (ignoring case). Uses the value as a
+   * tie-breaker (only really possible with a key that has a case change).
+   *
+   * @webref intdict:method
+   * @brief Sort the keys alphabetically in reverse
+   */
+  public void sortKeysReverse() {
+    sortImpl(true, true, true);
+  }
+
+
+  /**
+   * Sort by values in ascending order. The smallest value will be at [0].
+   *
+   * @webref intdict:method
+   * @brief Sort by values in ascending order
+   */
+  public void sortValues() {
+    sortValues(true);
+  }
+
+
+  /**
+   * Set true to ensure that the order returned is identical. Slightly
+   * slower because the tie-breaker for identical values compares the keys.
+   * @param stable
+   */
+  public void sortValues(boolean stable) {
+    sortImpl(false, false, stable);
+  }
+
+
+  /**
+   * Sort by values in descending order. The largest value will be at [0].
+   *
+   * @webref intdict:method
+   * @brief Sort by values in descending order
+   */
+  public void sortValuesReverse() {
+    sortValuesReverse(true);
+  }
+
+
+  public void sortValuesReverse(boolean stable) {
+    sortImpl(false, true, stable);
+  }
+
+
+  protected void sortImpl(final boolean useKeys, final boolean reverse,
+                          final boolean stable) {
+    Sort s = new Sort() {
+      @Override
+      public int size() {
+        return count;
+      }
+
+      @Override
+      public int compare(int a, int b) {
+        long diff = 0;
+        if (useKeys) {
+          diff = keys[a].compareToIgnoreCase(keys[b]);
+          if (diff == 0) {
+            diff = values[a] - values[b];
+          }
+        } else {  // sort values
+          diff = values[a] - values[b];
+          if (diff == 0 && stable) {
+            diff = keys[a].compareToIgnoreCase(keys[b]);
+          }
+        }
+        if (diff == 0) {
+          return 0;
+        } else if (reverse) {
+          return diff < 0 ? 1 : -1;
+        } else {
+          return diff < 0 ? -1 : 1;
+        }
+      }
+
+      @Override
+      public void swap(int a, int b) {
+        LongDict.this.swap(a, b);
+      }
+    };
+    s.run();
+
+    // Set the indices after sort/swaps (performance fix 160411)
+    resetIndices();
+  }
+
+
+  /**
+   * Sum all of the values in this dictionary, then return a new FloatDict of
+   * each key, divided by the total sum. The total for all values will be ~1.0.
+   * @return an IntDict with the original keys, mapped to their pct of the total
+   */
+  public FloatDict getPercent() {
+    double sum = sum();  // a little more accuracy
+    FloatDict outgoing = new FloatDict();
+    for (int i = 0; i < size(); i++) {
+      double percent = value(i) / sum;
+      outgoing.set(key(i), (float) percent);
+    }
+    return outgoing;
+  }
+
+
+  /** Returns a duplicate copy of this object. */
+  public LongDict copy() {
+    LongDict outgoing = new LongDict(count);
+    System.arraycopy(keys, 0, outgoing.keys, 0, count);
+    System.arraycopy(values, 0, outgoing.values, 0, count);
+    for (int i = 0; i < count; i++) {
+      outgoing.indices.put(keys[i], i);
+    }
+    outgoing.count = count;
+    return outgoing;
+  }
+
+
+  public void print() {
+    for (int i = 0; i < size(); i++) {
+      System.out.println(keys[i] + " = " + values[i]);
+    }
+  }
+
+
+  /**
+   * Save tab-delimited entries to a file (TSV format, UTF-8 encoding)
+   */
+  public void save(File file) {
+    PrintWriter writer = PApplet.createWriter(file);
+    write(writer);
+    writer.close();
+  }
+
+
+  /**
+   * Write tab-delimited entries to a PrintWriter
+   */
+  public void write(PrintWriter writer) {
+    for (int i = 0; i < count; i++) {
+      writer.println(keys[i] + "\t" + values[i]);
+    }
+    writer.flush();
+  }
+
+
+  /**
+   * Return this dictionary as a String in JSON format.
+   */
+  public String toJSON() {
+    StringList items = new StringList();
+    for (int i = 0; i < count; i++) {
+      items.append(JSONObject.quote(keys[i])+ ": " + values[i]);
+    }
+    return "{ " + items.join(", ") + " }";
+  }
+
+
+  @Override
+  public String toString() {
+    return getClass().getSimpleName() + " size=" + size() + " " + toJSON();
+  }
+}