From 629b6bc7444005915983ae8d86c89c4ae215729e Mon Sep 17 00:00:00 2001
From: Ben Culkin <scorpress@gmail.com>
Date: Tue, 26 Jul 2022 20:35:01 -0400
Subject: Restructure a bit

---
 src/main/java/bjc/data/Multimap.java           |  16 --
 src/main/java/bjc/esodata/.AbbrevTree.java.un~ | Bin 0 -> 33807 bytes
 src/main/java/bjc/esodata/AbbrevTree.java      | 276 +++++++++++++++++++++++++
 src/main/java/bjc/esodata/AbbrevTree.java~     |  75 +++++++
 src/main/java/bjc/esodata/Multimap.java        |  44 +++-
 src/main/java/bjc/esodata/ThresholdSet.java    |  74 ++++---
 src/main/java/module-info.java                 |   8 +
 7 files changed, 445 insertions(+), 48 deletions(-)
 delete mode 100644 src/main/java/bjc/data/Multimap.java
 create mode 100644 src/main/java/bjc/esodata/.AbbrevTree.java.un~
 create mode 100644 src/main/java/bjc/esodata/AbbrevTree.java
 create mode 100644 src/main/java/bjc/esodata/AbbrevTree.java~
 create mode 100644 src/main/java/module-info.java

(limited to 'src/main')

diff --git a/src/main/java/bjc/data/Multimap.java b/src/main/java/bjc/data/Multimap.java
deleted file mode 100644
index 0e858b7..0000000
--- a/src/main/java/bjc/data/Multimap.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package bjc.data;
-
-/**
- * A map with support for multiple values per key.
- *
- * @param <KeyType>
- *                    The type of the keys for the map.
- * @param <ValueType>
- *                    The type of the values for the map.
- *
- * @author Ben Culkin
- */
-public class Multimap<KeyType, ValueType> {
-	// TODO either implement this, or find if there is an implementation I've
-	// written elsewhere
-}
diff --git a/src/main/java/bjc/esodata/.AbbrevTree.java.un~ b/src/main/java/bjc/esodata/.AbbrevTree.java.un~
new file mode 100644
index 0000000..7c8a369
Binary files /dev/null and b/src/main/java/bjc/esodata/.AbbrevTree.java.un~ differ
diff --git a/src/main/java/bjc/esodata/AbbrevTree.java b/src/main/java/bjc/esodata/AbbrevTree.java
new file mode 100644
index 0000000..35c44f0
--- /dev/null
+++ b/src/main/java/bjc/esodata/AbbrevTree.java
@@ -0,0 +1,276 @@
+package bjc.esodata;
+
+import java.util.*;
+
+import bjc.data.Pair;
+import bjc.data.TransformIterator;
+import bjc.funcdata.FunctionalList;
+import bjc.funcdata.ListEx;
+
+/**
+ * A labeled tree, where you can reference sub-nodes by their label as long as
+ * the reference is unambiguous.
+ *
+ * Inspired by the way that you can reference COBOL members by their name, as
+ * long as it is unambiguous. If it is ambiguous, you can instead use parent
+ * nodes to disambiguate.
+ *
+ * Additional note: The base iterator will give you all of the child nodes, but
+ * in no defined order.
+ * 
+ * @param <Label>     The label on each node
+ * @param <Contained> The type of data contained in the nodes.
+ */
+public class AbbrevTree<Label, Contained> implements Iterable<Pair<Label, Contained>> {
+	private Multimap<Label, AbbrevTree<Label, Contained>> labelledNodes;
+
+	private Map<Label, AbbrevTree<Label, Contained>> children;
+	private AbbrevTree<Label, Contained> parent;
+
+	private Contained data;
+	private Label label;
+
+	/**
+	 * Create a new empty root AbbrevTree.
+	 */
+	public AbbrevTree() {
+		labelledNodes = new Multimap<>();
+		children = new HashMap<>();
+	}
+
+	/**
+	 * Create a new occupied root AbbrevTree
+	 * 
+	 * @param label The label for this tree
+	 * @param data  The data for this tree
+	 */
+	public AbbrevTree(Label label, Contained data) {
+		this();
+
+		this.label = label;
+		this.data = data;
+	}
+
+	/**
+	 * Create a new empty child AbbrevTree.
+	 * 
+	 * @param parent The parent of this node
+	 */
+	public AbbrevTree(AbbrevTree<Label, Contained> parent) {
+		labelledNodes = new Multimap<>();
+		children = new HashMap<>();
+
+		this.parent = parent;
+	}
+
+	/**
+	 * Create a new occupied child AbbrevTree
+	 * 
+	 * @param parent The parent of this node
+	 * @param label  The label for this tree
+	 * @param data   The data for this tree
+	 */
+	public AbbrevTree(AbbrevTree<Label, Contained> parent, Label label, Contained data) {
+		this();
+
+		this.parent = parent;
+		this.label = label;
+		this.data = data;
+
+		addFromChild(label, this);
+	}
+
+	private void addFromChild(Label lbl, AbbrevTree<Label, Contained> node) {
+		labelledNodes.add(lbl, node);
+
+		if (parent != null)
+			parent.addFromChild(lbl, node);
+	}
+
+	/**
+	 * Get the data contained in this node.
+	 * 
+	 * @return The contained data.
+	 */
+	public Contained getData() {
+		return data;
+	}
+
+	/**
+	 * Set the data contained in this node.
+	 * 
+	 * @param data The new data.
+	 */
+	public void setData(Contained data) {
+		this.data = data;
+	}
+
+	/**
+	 * Get the label for this node.
+	 * 
+	 * @return The label for this node.
+	 */
+	public Label getLabel() {
+		return label;
+	}
+
+	/*
+	 * Unsupported for now. This requires some additional scaffolding.
+	 * 
+	 * Set the label for this node.
+	 * 
+	 * @param label The new label for this node.
+	 */
+	// public void setLabel(Label label) {
+	// this.label = label;
+	// }
+
+	/**
+	 * Add a child to this node
+	 * 
+	 * @param key The label for the new node
+	 * @param dat The data for the new node.
+	 * 
+	 * @return The new node
+	 */
+	public AbbrevTree<Label, Contained> add(Label key, Contained dat) {
+		AbbrevTree<Label, Contained> node = new AbbrevTree<>(this, key, dat);
+
+		children.put(key, node);
+
+		return node;
+	}
+
+	/**
+	 * Remove a direct child from this node.
+	 * 
+	 * @param key The label for this child.
+	 * 
+	 * @return The removed child.
+	 */
+	public Optional<AbbrevTree<Label, Contained>> removeChild(Label key) {
+		Optional<AbbrevTree<Label, Contained>> res = Optional.ofNullable(children.remove(key));
+
+		res.ifPresent((node) -> {
+			node.parent = null;
+			node.labelledNodes.iterator().forEachRemaining((par) -> {
+				labelledNodes.remove(par.getLeft(), par.getRight());
+
+				parent.labelledNodes.remove(par.getLeft(), par.getRight());
+			});
+		});
+
+		return res;
+	}
+
+	/**
+	 * Retrieve a number of subnodes from this tree which correspond to the given
+	 * keys.
+	 * 
+	 * Note that the keys are passed in reverse order. Essentially, the first
+	 * argument is the actual key, the remainder are just disambiguators
+	 * 
+	 * @param keys The keys to look up.
+	 * 
+	 * @return All of the nodes which match the given key pattern.
+	 */
+	public Set<AbbrevTree<Label, Contained>> nodes(@SuppressWarnings("unchecked") Label... keys) {
+		// Need this; Java can't deduce the proper type for reduceAux otherwise
+		Set<AbbrevTree<Label, Contained>> nodes = new HashSet<>();
+
+		ListEx<Label> keyList = new FunctionalList<>(keys);
+
+		// COBOL keylists are in reverse order
+		keyList.reverse();
+
+		Label last = keyList.popLast();
+
+		List<AbbrevTree<Label, Contained>> focusList = List.of(this);
+		for (Label key : keyList) {
+			List<AbbrevTree<Label, Contained>> nextFocus = new ArrayList<>();
+
+			for (AbbrevTree<Label, Contained> focus : focusList) {
+				Set<AbbrevTree<Label, Contained>> focusSet = focus.labelledNodes.get(key);
+				nextFocus.addAll(focusSet);
+			}
+
+			focusList = nextFocus;
+		}
+
+		focusList.forEach((focus) -> {
+			nodes.addAll(focus.labelledNodes.get(last));
+		});
+
+		if (label.equals(last))
+			nodes.add(this);
+
+		return nodes;
+	}
+
+	/**
+	 * Retrieve all of the values which correspond to a given key.
+	 * 
+	 * 
+	 * Note that the keys are passed in reverse order. Essentially, the first
+	 * argument is the actual key, the remainder are just disambiguators
+	 * 
+	 * @param keys The keys to look up
+	 * 
+	 * @return All of the values which correspond to the key
+	 */
+	public Set<Contained> values(@SuppressWarnings("unchecked") Label... keys) {
+		Set<Contained> res = new HashSet<>();
+
+		nodes(keys).forEach((node) -> res.add(node.data));
+
+		return res;
+	}
+
+	/**
+	 * Returns the singular value identified by the given keypath.
+	 * 
+	 * Note that unlike {@link AbbrevTree#nodes(Object...)} and
+	 * {@link AbbrevTree#values(Object...)}, the keys to this method are passed in
+	 * the proper order, not reverse.
+	 * 
+	 * @param keys The keypath to look up.
+	 * 
+	 * @return An optional containing the identified element if there is one;
+	 *         otherwise, empty.
+	 */
+	public Optional<AbbrevTree<Label, Contained>> path(@SuppressWarnings("unchecked") Label... keys) {
+		Optional<AbbrevTree<Label, Contained>> focus = Optional.of(this);
+
+		for (Label key : keys) {
+			focus.map((node) -> {
+				return node.children.get(key);
+			});
+		}
+
+		return focus;
+	}
+
+	@Override
+	public Iterator<Pair<Label, Contained>> iterator() {
+		return new TransformIterator<>(labelledNodes.iterator(),
+				(node) -> node.mapRight(AbbrevTree<Label, Contained>::getData));
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(children, data, label, parent);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		AbbrevTree<?, ?> other = (AbbrevTree<?, ?>) obj;
+		return Objects.equals(children, other.children) && Objects.equals(data, other.data)
+				&& Objects.equals(label, other.label);
+	}
+}
diff --git a/src/main/java/bjc/esodata/AbbrevTree.java~ b/src/main/java/bjc/esodata/AbbrevTree.java~
new file mode 100644
index 0000000..a391028
--- /dev/null
+++ b/src/main/java/bjc/esodata/AbbrevTree.java~
@@ -0,0 +1,75 @@
+package bjc.esodata;
+
+import java.util.*;
+
+/**
+ * A labeled tree, where you can reference sub-nodes by their label as long as the reference is unambiguous.
+ *
+ * Inspired by the way that you can reference COBOL members by their name, as long as it is unambiguous. If it is ambiguous, you can instead use parent nodes to disambiguate.
+ *
+ * @param <Contained> The type of data contained in the nodes.
+ */
+public class AbbrevTree<Contained> {
+	/** Represents a single node in an AbbrevTree */
+	public interface AbbrevNode<Contained> {
+		/** The label for the node. */
+		public String getLabel();
+		/** The data for the node. */
+		public Contained getData();
+		/**
+		 * Add a child to this node.
+		 * 
+		 * If a node already exists with the given label, it will be replaced.
+		 *
+		 * @param label The label for the child.
+		 * @param contained The data contained in the child.
+		 */
+		public void addChild(String label, String contained);
+		/**
+		 * Get a child, starting the search from this node.
+		 * @param labels The label(s) to search for. If the label is ambiguous, provide additional ones to make it unambiguous.
+		 */
+		public AbbrevNode<Contained> getNode(String... labels);
+	}
+
+	public Contained get(String... labels) {
+		return null;		
+	}
+}
+
+class AbbrevNode<Contained> {
+	private String label;
+	private Contained data;
+
+	private List<AbbrevNode<Contained>> children;
+	private AbbrevTree<Contained> container;
+
+	/**
+	 * Create a new AbbrevNode with a label and contents.
+	 * @param label The label for this node.
+	 * @param data The data contained in the node.
+	 * @param container The tree that contains the node.
+	 */
+	public AbbrevNode(String label, Contained data, AbbrevTree<Contained> container) {
+		this(container);
+
+		this.label = label;
+		this.data = data;
+	}
+
+	/**
+	 * Get the label for this node.
+	 * @return The label for this node.
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * Get the data for this node.
+	 * @return The data for this node.
+	 */
+	public Contained getData() {
+		return data;
+	}
+}
diff --git a/src/main/java/bjc/esodata/Multimap.java b/src/main/java/bjc/esodata/Multimap.java
index fae872e..e18ed49 100644
--- a/src/main/java/bjc/esodata/Multimap.java
+++ b/src/main/java/bjc/esodata/Multimap.java
@@ -1,6 +1,9 @@
 package bjc.esodata;
 
 import java.util.*;
+import java.util.Map.Entry;
+
+import bjc.data.Pair;
 
 /**
  * A map that has support for multiple values for a given key.
@@ -14,7 +17,7 @@ import java.util.*;
  * @param <KeyType> The type of keys in the map.
  * @param <ValueType> The type of values in the map.
  */
-public class Multimap<KeyType, ValueType> {
+public class Multimap<KeyType, ValueType> implements Iterable<Pair<KeyType, ValueType>> {
 	private Map<KeyType, ThresholdSet<ValueType>> backing;
 
 	/**
@@ -79,6 +82,17 @@ public class Multimap<KeyType, ValueType> {
 		else                           return backing.get(key).values();
 	}
 
+	/**
+	 * Get the single value in the map, if there is one.
+	 * @param key The key to look up
+	 * @return An optional containing the key if it is there once, or empty if it is there either no or more than one times
+	 */
+	public Optional<ValueType> getSingle(KeyType key) {
+		Set<ValueType> set = get(key);
+		
+		if (set.size() == 1) return Optional.of(set.iterator().next());
+		return Optional.empty();
+	}
 	/**
 	 * Check if there is at least one value mapped to the given key.
 	 *
@@ -108,4 +122,32 @@ public class Multimap<KeyType, ValueType> {
 
 		return backing.get(key).contains(value) > 0;
 	}
+	
+	@Override
+	public Iterator<Pair<KeyType, ValueType>> iterator() {
+		return new Iterator<>() {
+			private Iterator<Entry<KeyType, ThresholdSet<ValueType>>> mapIter = backing.entrySet().iterator();
+			private KeyType currKey;
+			private Iterator<ValueType> setIter;
+			
+			@Override
+			public boolean hasNext() {
+				while (setIter == null || !setIter.hasNext()) {
+					if (!mapIter.hasNext()) return false;
+					Entry<KeyType,ThresholdSet<ValueType>> entry = mapIter.next();
+					
+					currKey = entry.getKey();
+					setIter = entry.getValue().setView().iterator();
+				}
+				
+				return setIter.hasNext();
+			}
+			
+			@Override
+			public Pair<KeyType, ValueType> next() {
+				if (setIter == null || !setIter.hasNext()) throw new NoSuchElementException();
+				return Pair.pair(currKey, setIter.next()) ;
+			}
+		};
+	}
 }
diff --git a/src/main/java/bjc/esodata/ThresholdSet.java b/src/main/java/bjc/esodata/ThresholdSet.java
index 9b8560b..c13bad3 100644
--- a/src/main/java/bjc/esodata/ThresholdSet.java
+++ b/src/main/java/bjc/esodata/ThresholdSet.java
@@ -2,6 +2,10 @@ package bjc.esodata;
 
 import java.util.*;
 
+import bjc.data.Pair;
+import bjc.data.SimplePair;
+import bjc.data.TransformIterator;
+
 /**
  * Represents a counted set, that overflows to a map.
  *
@@ -17,12 +21,11 @@ import java.util.*;
  * The iterator that this type gives by default is an iterator over all of the
  * values in the set, not including any of those in the map.
  *
- * @param <KeyType>
- *                  The value being counted.
+ * @param <KeyType> The value being counted.
  *
  * @author Ben Culkin
  */
-public class ThresholdSet<KeyType> {
+public class ThresholdSet<KeyType> implements Iterable<Pair<KeyType, Integer>> {
 	// View of this class as a java.util.Set
 	private class SetView extends AbstractSet<KeyType> {
 		/*
@@ -37,7 +40,8 @@ public class ThresholdSet<KeyType> {
 			int ret = ThresholdSet.this.add(key);
 
 			// No change to set contents
-			if (ret > 2) return false;
+			if (ret > 2)
+				return false;
 
 			return true;
 		}
@@ -51,7 +55,8 @@ public class ThresholdSet<KeyType> {
 			int ret = ThresholdSet.this.remove(k);
 
 			// We removed the element.
-			if (ret == 0) return true;
+			if (ret == 0)
+				return true;
 
 			return false;
 		}
@@ -65,7 +70,8 @@ public class ThresholdSet<KeyType> {
 			int ret = ThresholdSet.this.contains(k);
 
 			// The object is set-visible
-			if (ret == 1) return true;
+			if (ret == 1)
+				return true;
 
 			return false;
 		}
@@ -101,15 +107,15 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Add multiple keys at once to the map.
 	 *
-	 * @param keys
-	 *             The keys to add.
+	 * @param keys The keys to add.
 	 *
 	 * @return An array containing the results of adding the keys.
 	 */
 	public int[] addKeys(@SuppressWarnings("unchecked") KeyType... keys) {
 		int[] ret = new int[keys.length];
 
-		for (int i = 0; i < keys.length; i++) ret[i] = add(keys[i]);
+		for (int i = 0; i < keys.length; i++)
+			ret[i] = add(keys[i]);
 
 		return ret;
 	}
@@ -117,11 +123,10 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Add a key to the collection.
 	 *
-	 * @param key
-	 *            The key to add to the collection.
+	 * @param key The key to add to the collection.
 	 *
 	 * @return The number of times that key now exists in the collection. Should
-	 *         always be &lt; 0.
+	 *         always be &gt; 0.
 	 */
 	public int add(KeyType key) {
 		if (keySet.contains(key)) {
@@ -149,15 +154,15 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Remove a bunch of keys from the collection.
 	 *
-	 * @param keys
-	 *             The keys to remove from the collection.
+	 * @param keys The keys to remove from the collection.
 	 *
 	 * @return The results from removing the keys.
 	 */
 	public int[] removeKeys(@SuppressWarnings("unchecked") KeyType... keys) {
 		int[] ret = new int[keys.length];
 
-		for (int i = 0; i < keys.length; i++) ret[i] = remove(keys[i]);
+		for (int i = 0; i < keys.length; i++)
+			ret[i] = remove(keys[i]);
 
 		return ret;
 	}
@@ -165,8 +170,7 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Remove a key from the collection.
 	 *
-	 * @param key
-	 *            The key to remove from the collection.
+	 * @param key The key to remove from the collection.
 	 *
 	 * @return The number of times that key now exists in the collection. Returns -1
 	 *         if that key wasn't in the collection beforehand.
@@ -188,11 +192,11 @@ public class ThresholdSet<KeyType> {
 				keySet.add(key);
 
 				return 1;
-			} else {
-				keyMap.put(key, cnt);
-
-				return cnt;
 			}
+
+			keyMap.put(key, cnt);
+
+			return cnt;
 		} else {
 			// We don't know about that key
 			return -1;
@@ -202,15 +206,15 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Get the number of times the set contains a set of given keys.
 	 *
-	 * @param keys
-	 *             The keys to look for.
+	 * @param keys The keys to look for.
 	 *
 	 * @return The containment counts for each key.
 	 */
 	public int[] containsKeys(@SuppressWarnings("unchecked") KeyType... keys) {
 		int[] ret = new int[keys.length];
 
-		for (int i = 0; i < keys.length; i++) ret[i] = contains(keys[i]);
+		for (int i = 0; i < keys.length; i++)
+			ret[i] = contains(keys[i]);
 
 		return ret;
 	}
@@ -218,15 +222,17 @@ public class ThresholdSet<KeyType> {
 	/**
 	 * Get the number of times the set contains a given key.
 	 *
-	 * @param key
-	 *            The key to look for.
+	 * @param key The key to look for.
 	 *
 	 * @return The number of times the key occurs; -1 if it doesn't occur.
 	 */
 	public int contains(KeyType key) {
-		if (keySet.contains(key))     return 1;
-		if (!keyMap.containsKey(key)) return -1;
-		else                          return keyMap.get(key);
+		if (keySet.contains(key))
+			return 1;
+		if (!keyMap.containsKey(key))
+			return -1;
+
+		return keyMap.get(key);
 	}
 
 	/**
@@ -252,12 +258,18 @@ public class ThresholdSet<KeyType> {
 		return new SetView();
 	}
 
+	@Override
+	public Iterator<Pair<KeyType, Integer>> iterator() {
+		return new TransformIterator<>(keyMap.entrySet().iterator(),
+				(entry) -> new SimplePair<>(entry.getKey(), entry.getValue()));
+	}
+
 	/**
 	 * Static threshold set constructor.
+	 * 
 	 * @param <KType> The type of keys for the threshold set.
 	 *
-	 * @param keys
-	 *             The initial keys to add to the threshold set.
+	 * @param keys    The initial keys to add to the threshold set.
 	 * @return A threshold set with the given keys.
 	 */
 	@SafeVarargs
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
new file mode 100644
index 0000000..84d1b2f
--- /dev/null
+++ b/src/main/java/module-info.java
@@ -0,0 +1,8 @@
+module esodata {
+	exports bjc.data;
+	exports bjc.esodata;
+	exports bjc.functypes;
+	exports bjc.funcdata.bst;
+	exports bjc.funcdata.theory;
+	exports bjc.funcdata;
+}
\ No newline at end of file
-- 
cgit v1.2.3