Adapt to esodata changes

7 files changed, 27 insertions, 27 deletions

diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
index 434b47f..038b6ea 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ChainParseBlock.java
@@ -4,8 +4,8 @@ import java.util.Set;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -51,19 +51,19 @@ public class ChainParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException {
-		ITree<Token<K, V>> expression = iner.parse(ctx);
+	public Tree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException {
+		Tree<Token<K, V>> expression = iner.parse(ctx);
 
 		Token<K, V> currentToken = ctx.tokens.current();
 		if(indicators.contains(currentToken.getKey())) {
-			ITree<Token<K, V>> res = new Tree<>(trm);
+			Tree<Token<K, V>> res = new SimpleTree<>(trm);
 			res.addChild(expression);
 
 			while(indicators.contains(currentToken.getKey())) {
-				res.addChild(new Tree<>(currentToken));
+				res.addChild(new SimpleTree<>(currentToken));
 				ctx.tokens.next();
 
-				ITree<Token<K, V>> innerExpression = iner.parse(ctx);
+				Tree<Token<K, V>> innerExpression = iner.parse(ctx);
 				res.addChild(innerExpression);
 
 				currentToken = ctx.tokens.current();
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
index 0b1fb36..2432d6e 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java
@@ -6,7 +6,7 @@ import bjc.pratt.ParserContext;
 import bjc.pratt.PrattParser;
 import bjc.pratt.tokens.Token;
 import bjc.pratt.tokens.TokenStream;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.functypes.*;
 import bjc.utils.parserutils.ParserException;
 
@@ -41,7 +41,7 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 
 	private final Function<TokenStream<K, V>, TokenStream<K2, V2>> tkenTransform;
 	private final Isomorphism<C, C2> stteTransform;
-	private final Function<ITree<Token<K2, V2>>, ITree<Token<K, V>>> xpressionTransform;
+	private final Function<Tree<Token<K2, V2>>, Tree<Token<K, V>>> xpressionTransform;
 
 	/**
 	 * Create a new grammar parser block.
@@ -56,7 +56,7 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 	public GrammarParseBlock(final PrattParser<K2, V2, C2> inner, final int precedence, final boolean isStatement,
 			final Function<TokenStream<K, V>, TokenStream<K2, V2>> tokenTransform,
 			final Isomorphism<C, C2> stateTransform,
-			final Function<ITree<Token<K2, V2>>, ITree<Token<K, V>>> expressionTransform) {
+			final Function<Tree<Token<K2, V2>>, Tree<Token<K, V>>> expressionTransform) {
 		innr = inner;
 		prcedence = precedence;
 		isStatemnt = isStatement;
@@ -66,12 +66,12 @@ public class GrammarParseBlock<K, V, C, K2, V2, C2> implements ParseBlock<K, V,
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
 		final C2 newState = stteTransform.to(ctx.state);
 
 		final TokenStream<K2, V2> newTokens = tkenTransform.apply(ctx.tokens);
 
-		final ITree<Token<K2, V2>> expression = innr.parseExpression(prcedence, newTokens, newState,
+		final Tree<Token<K2, V2>> expression = innr.parseExpression(prcedence, newTokens, newState,
 				isStatemnt);
 
 		ctx.state = stteTransform.from(newState);
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
index d6cfda9..81ba508 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlock.java
@@ -2,7 +2,7 @@ package bjc.pratt.blocks;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -34,6 +34,6 @@ public interface ParseBlock<K, V, C> {
 	 *         If something goes wrong during parsing, or the block fails
 	 *         validation.
 	 */
-	ITree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException;
+	Tree<Token<K, V>> parse(ParserContext<K, V, C> ctx) throws ParserException;
 
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
index e0d63f3..96b9737 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java
@@ -4,7 +4,7 @@ import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
 
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 
 /**
  * Utility class for creating common implementations of {@link ParseBlock}
@@ -91,7 +91,7 @@ public class ParseBlocks {
 	 * @return A configured simple parse block.
 	 */
 	public static <K, V, C> ParseBlock<K, V, C> simple(final int precedence, final K terminator,
-			final Predicate<ITree<Token<K, V>>> validator) {
+			final Predicate<Tree<Token<K, V>>> validator) {
 		return new SimpleParseBlock<>(precedence, validator, terminator);
 	}
 }
\ No newline at end of file
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
index fafccf1..4c21358 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/RepeatingParseBlock.java
@@ -4,8 +4,8 @@ import java.util.function.UnaryOperator;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
 import bjc.data.Tree;
+import bjc.data.SimpleTree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -72,13 +72,13 @@ public class RepeatingParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> ret = new Tree<>(mark);
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+		final Tree<Token<K, V>> ret = new SimpleTree<>(mark);
 
 		Token<K, V> tok = ctx.tokens.current();
 
 		while(!tok.getKey().equals(term)) {
-			final ITree<Token<K, V>> kid = innerBlock.parse(ctx);
+			final Tree<Token<K, V>> kid = innerBlock.parse(ctx);
 			ret.addChild(kid);
 
 			tok = ctx.tokens.current();
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
index 6dd925e..83e1d91 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/SimpleParseBlock.java
@@ -4,7 +4,7 @@ import java.util.function.Predicate;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -26,7 +26,7 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 
 	private final K term;
 
-	private final Predicate<ITree<Token<K, V>>> validatr;
+	private final Predicate<Tree<Token<K, V>>> validatr;
 
 	/**
 	 * Create a new block.
@@ -39,7 +39,7 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	 *        The token type that terminates the block. If this is null,
 	 *        don't check for a terminator.
 	 */
-	public SimpleParseBlock(final int precedence, final Predicate<ITree<Token<K, V>>> validator,
+	public SimpleParseBlock(final int precedence, final Predicate<Tree<Token<K, V>>> validator,
 			final K terminator) {
 		if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative");
 
@@ -49,8 +49,8 @@ public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
-		final ITree<Token<K, V>> res = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false);
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+		final Tree<Token<K, V>> res = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false);
 
 		if(term != null) {
 			ctx.tokens.expect(term);
diff --git a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
index f29e3b7..bfe5ab3 100644
--- a/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
+++ b/JPratt/src/main/java/bjc/pratt/blocks/TriggeredParseBlock.java
@@ -4,7 +4,7 @@ import java.util.function.UnaryOperator;
 
 import bjc.pratt.ParserContext;
 import bjc.pratt.tokens.Token;
-import bjc.data.ITree;
+import bjc.data.Tree;
 import bjc.utils.parserutils.ParserException;
 
 /**
@@ -45,12 +45,12 @@ public class TriggeredParseBlock<K, V, C> implements ParseBlock<K, V, C> {
 	}
 
 	@Override
-	public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
+	public Tree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
 		final C newState = onEntr.apply(ctx.state);
 
 		final ParserContext<K, V, C> newCtx = new ParserContext<>(ctx.tokens, ctx.parse, newState);
 
-		final ITree<Token<K, V>> res = sourc.parse(newCtx);
+		final Tree<Token<K, V>> res = sourc.parse(newCtx);
 
 		ctx.state = onExt.apply(newState);