StreamableTree (base) + debug value

src/dev/peerat/parser/Bag.java

@@ -54,6 +54,7 @@ public class Bag{
 	
 	public void set(String key, Object value){
 		this.map.put(key, value);
+		System.out.println("edit Bag "+this);
 	}
 	
 	@Override

src/dev/peerat/parser/Token.java

@@ -33,13 +33,19 @@ public class Token{
 	
 	//line & character start & end ?
 	public Token concat(Token token){
-		StackTraceElement[] stack = Thread.currentThread().getStackTrace();
-		System.out.println(token.getValue()+":");
-		for(int i = 1; i < stack.length; i++) System.out.println(stack[i]);
-		System.out.println();
 		return new Token(line, character, value+token.getValue(), TokenType.GROUP);
 	}
 	
+	@Override
+	public boolean equals(Object obj){
+		if(obj == null) return false;
+		if(obj instanceof Token){
+			Token token = (Token)obj;
+			return this.line == token.line && this.character == token.character && ((this.value == null && token.value == null) || (this.value.equals(token.value))) && this.type.equals(token.type);
+		}
+		return false;
+	}
+	
 	@Override
 	public String toString(){
 		return "Token["+line+";"+character+";"+type+";"+value+"]";

src/dev/peerat/parser/TokenValidator.java

@@ -35,6 +35,12 @@ public class TokenValidator{
 				TOKENS = elements.length;
 			}
 			this.validated++;
+			
+			StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+			int current = 0;
+			while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
+			System.out.println("[validate] "+trace[current]);
+			
 			return true;
 		}
 		return false;
@@ -49,7 +55,7 @@ public class TokenValidator{
 	}
 	
 	public TokenValidator branch(){
-		TokenValidator branch = new TokenValidator(new Bag(bag));
+		TokenValidator branch = new TokenValidator(bag);
 		branch.elements = this.elements;
 		branch.index = Math.max(0, this.validated-1);
 		branch.validated = this.validated;

src/dev/peerat/parser/TreeStreamable.java

@@ -0,0 +1,3 @@
+package dev.peerat.parser;
+
+public interface TreeStreamable{}

src/dev/peerat/parser/java/Class.java

@@ -2,8 +2,12 @@ package dev.peerat.parser.java;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Predicate;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.java.Function.FunctionStreamable;
+import dev.peerat.parser.java.Variable.VariableStreamable;
 
 public class Class extends ClassBase{
 	
@@ -103,4 +107,23 @@ public class Class extends ClassBase{
 			}
 		}
 	}
+	
+	public ClassStreamable stream(){
+		return new ClassStreamable();
+	}
+
+	public class ClassStreamable implements TreeStreamable{
+		
+		public ClassStreamable(){}
+		
+		public FunctionStreamable functionFilter(Predicate<Function> filter){ return null; }
+		
+		public FunctionStreamable constructorFilter(Predicate<Function> filter){ return null; }
+		
+		public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
+		
+		public ClassStreamable classFilter(Predicate<Class> filter){ return null; }
+//		public InterfaceStreamable interfaceFilter(Predicate<Interface> filter){ return null; }
+//		public EnumStreamable enumFilter(Predicate<Enumeration> filter){ return null; }
+	}
 }

src/dev/peerat/parser/java/Function.java

@@ -3,14 +3,15 @@ package dev.peerat.parser.java;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.List;
-
+import java.util.function.Predicate;
-import javax.xml.crypto.dsig.CanonicalizationMethod;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.TokenType;
+import dev.peerat.parser.TreeStreamable;
 import dev.peerat.parser.java.Annotation.Annotable;
 import dev.peerat.parser.java.Operation.OperationContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.Variable.VariableStreamable;
 
 public class Function extends Annotable implements VariableContainer, OperationContainer{
 	
@@ -159,4 +160,15 @@ public class Function extends Annotable implements VariableContainer, OperationC
 			}
 		}
 	}
+	
+	public FunctionStreamable stream(){
+		return new FunctionStreamable();
+	}
+
+	public class FunctionStreamable implements TreeStreamable{
+		
+		public FunctionStreamable(){}
+		
+		public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
+	}
 }

src/dev/peerat/parser/java/JavaElement.java

@@ -8,9 +8,6 @@ import dev.peerat.parser.ElementBuilder;
 
 public abstract class JavaElement implements ElementBuilder{	
 	
-//	Bag bag; //to remove
-	
-	
 	public abstract <E extends JavaElement> E find(Function<JavaElement, Boolean> finder);
 	
 	public abstract <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list);

src/dev/peerat/parser/java/JavaFile.java

@@ -102,4 +102,5 @@ public class JavaFile extends JavaElement implements ClassContainer, AnnotableBu
 			clazz.findAll(finder, list);
 		}
 	}
+	
 }

src/dev/peerat/parser/java/JavaParser.java

@@ -307,6 +307,8 @@ public class JavaParser extends Parser<JavaElement> {
 		
 		//VALUE
 		BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
+			System.out.println("value_builder {");
+			System.out.println("begin: "+bag);
 			if(bag.has("right")){
 				
 				if(!(bag.get("left") instanceof Value)) bag.set("left", new StaticValue(bag.<Token>get("left")));
@@ -321,10 +323,17 @@ public class JavaParser extends Parser<JavaElement> {
 						bag.get("right"));
 				bag.set(result);
 			}
+			System.out.println("end: "+bag);
+			System.out.println("}");
 			return null;
 		};
 		
 		BiConsumer<Bag, Bag> value_right =  (global, local) -> {
+			System.out.println("merge{");
+			System.out.println("global: "+global);
+			System.out.println("local: "+local);
+			System.out.println("More than simple merge ? "+local.get().getClass());
+			System.out.println("}");
 			global.set("right", local.get("left"));
 		};
 		
@@ -370,10 +379,15 @@ public class JavaParser extends Parser<JavaElement> {
 					.multiple(braces_container)
 					.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
 		value_name = value_name.then(new RedirectStateTree<>(type, (global, local) -> {
+			System.out.println("value_name {");
+			System.out.println("global: "+global);
+			System.out.println("local: "+local);
+			System.out.println("}");
 			if(global.get() == null) global.set(local.get());
 			else global.set(global.<Token>get().concat(local.get()));
 		}));
 		value_name.end((parent,bag) -> {
+			System.out.println("{value_name} "+bag);
 			Value result = new StaticValue(bag.<Token>get());
 			bag.set(result);
 			return null;
@@ -499,6 +513,7 @@ public class JavaParser extends Parser<JavaElement> {
 		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
 		StateTree<JavaElement> value_inside = value_container.then(new RedirectStateTree<>(value, (global, local) -> {
 			global.set("left", local.get());
+			System.out.println("value_inside "+global);
 		}));
 		value_inside.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
 			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
@@ -506,6 +521,7 @@ public class JavaParser extends Parser<JavaElement> {
 			.then(value_left);
 		value_inside.then(value_left);
 		value_left.end((parent, bag) -> {
+			System.out.println("value_left -> end "+bag);
 			if(bag.get("left") instanceof Value) bag.set(bag.get("left"));
 			else bag.set(new StaticValue(bag.<Token>get("left")));
 			return null;
@@ -782,6 +798,10 @@ public class JavaParser extends Parser<JavaElement> {
 		
 		StateTree<JavaElement> operation_if = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("if")))
 			.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+			.then((v) -> {
+				System.out.println("inside IF");
+				return true;
+			})
 			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(local.get())))
 			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
 			.end((parent,bag) -> {
@@ -1281,310 +1301,4 @@ public class JavaParser extends Parser<JavaElement> {
 		return 0;
 	}
 	
-//	public static void main(String[] args) throws Exception{
-//		File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\peer-at-code-backend\\src\\dev\\peerat\\backend\\routes\\users\\ChangePassword.java");
-//		
-//		BufferedReader reader = new BufferedReader(new FileReader(file));
-//		
-//		time = System.currentTimeMillis();
-//		
-//		Parser<JavaElement> parser = new JavaParser();
-//		JavaFile jFile = new JavaFile();
-//		parser.parse(reader, jFile);
-//		
-//		List<Value> values = new ArrayList<>();
-//		jFile.findAll((e) -> e instanceof Value, values);
-//		System.out.println("Find "+values.size()+" values");
-//		for(Value v : values) System.out.println(v.getClass().getSimpleName()+" ->"+v);
-//		
-//
-//		System.out.println((System.currentTimeMillis()-time)+"ms");
-//		
-//		System.out.println(TokenValidator.MAX_VALIDATE+" / "+TokenValidator.TOKENS);
-//		
-////		parser.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
-//		Builder builder = new Builder();
-//		jFile.build(builder);
-//		builder.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
-//	}
-	
-	
-	
-	
-	
-	
-	/*
-	 * 
-	 * VALUES
-	 * 
-	 
-	 
-	 
-	 //VALUE
-		BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
-			if(bag.has("right")){
-				
-				if(!(bag.get("left") instanceof Value)) bag.set("left", new Value(bag.<Token>get("left")));
-				if(!(bag.get("right") instanceof Value)) bag.set("right", new Value(bag.<Token>get("right")));
-				
-				BiValue result = new BiValue(
-						
-						bag.get("left"),
-						
-						bag.get("action"),
-						
-						bag.get("right"));
-				bag.set(result);
-			}
-			return null;
-		};
-		
-		BiConsumer<Bag, Bag> value_right =  (global, local) -> {
-			global.set("right", local.get("left"));
-		};
-		
-		//STRING CONCAT
-	 StateTree<JavaElement> value = new StateTree<>();
-		
-		StateTree<JavaElement> value_container = new StateTree<>();
-		
-		StateTree<JavaElement> value_list = new StateTree<>();
-		StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value_container, (global, local) -> {
-			List<Value> list = global.get();
-			if(list == null){
-				list = new ArrayList<>();
-				global.set(list);
-			}
-			list.add(local.get());
-		}));
-		value_list_element.end();
-		value_list_element.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
-			.then(value_list_element);
-		
-		value.then((validator) -> validator.validate(
-				(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
-				(bag, token) -> bag.set(token)))
-		.end((parent,bag) -> {
-			bag.set(new Value(bag.<Token>get()));
-			return null;
-		});
-		
-		StateTree<JavaElement> value_instance = value.then((validator) -> validator.validate(
-				(token) -> token.getValue().equals("new"),
-				(bag, token) -> bag.set("newit", token)));
-		StateTree<JavaElement> value_name = new StateTree<JavaElement>();
-		value.then(value_name);
-		value_instance.then(new RedirectStateTree<>(value_name, (global, local) -> {
-			System.out.println(local.get()+"");
-			if(global.has("newit")) global.set(new InstanceValue(global.<Token>get("newit"), local.<MethodCallValue>get().getToken(), local.<MethodCallValue>get().getParameters()));
-			else global.set(local.get());
-		}))
-			.end((a,b) -> a)
-				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
-				.end((a,b) -> a)
-					.multiple(braces_container)
-					.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
-		value_name = value_name.then(new RedirectStateTree<>(type, (global, local) -> {
-			if(global.get() == null) global.set(local.get());
-			else global.set(global.<Token>get().concat(local.get()));
-		}));
-		value_name.end((parent,bag) -> {
-			Value result = new Value(bag.<Token>get());
-			bag.set(result);
-			return null;
-		});
-		
-		value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(":")) && validator.validate((token) -> token.getValue().equals(":")))
-			.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
-			.end((a,b) -> a);
-		
-		StateTree<JavaElement> value_call = value_name.then((validator) -> validator.validate(
-				(token) -> token.getValue().equals("."),
-				(bag, token) -> {
-					Value prev = bag.get("prev");
-					if(prev == null){
-						bag.set("prev", new Value(bag.<Token>get()));
-					}else{
-						Integer paramters = bag.get("args");
-						List<Value> list = null;
-						if(paramters != null){
-							list = new ArrayList<>();
-							for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
-							bag.remove("args");
-						}
-						MethodCallValue methodCall = new MethodCallValue(prev, bag.get("gen"), bag.get(), list);
-						bag.set("prev", methodCall);
-						bag.remove("gen");
-					}
-					bag.set(new Token(token.getLineNumber(), token.getCharacterNumber(), "", TokenType.GROUP));
-				}));
-		value_call.end((a,b) -> a);
-		value_call.then(new RedirectStateTree<>(gen, (global, local) -> global.set("gen", global.<Token>get().concat(local.get())))).then(value_name);
-		value_call.then(value_name);
-		StateTree<JavaElement> value_array_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
-		StateTree<JavaElement> value_array_end = value_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
-		value_array_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("inside", local)))
-			.then(value_array_end);
-		value_array_end.end((parent,bag) -> {
-			//to change
-			bag.set(new MethodCallValue(null, null, bag.get(), null));
-			return parent;
-		})
-			.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
-			.end((a,b) -> a)
-				.multiple(value_list)
-				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
-		value_array_end.then(value_call);
-		value_array_end.then(value_array_begin);
-		
-		StateTree<JavaElement> value_arg_begin = value_name.then((validator) -> validator.validate(
-				(token) -> token.getValue().equals("("),
-				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
-		StateTree<JavaElement> value_arg_end = value_arg_begin.then((validator) -> validator.validate(
-				(token) -> token.getValue().equals(")"),
-				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
-		value_arg_end.end((parent,bag) -> {
-			Integer paramters = bag.get("args");
-			List<Value> list = null;
-			if(paramters != null){
-				list = new ArrayList<>();
-				for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
-			}
-			
-			MethodCallValue methodCall = new MethodCallValue(bag.get("prev"), bag.get("gen"), bag.get(), list);
-			bag.set(methodCall);
-			return null;
-		});
-		value_arg_end.then(value_call);
-		value_arg_end.then(value_array_begin);
-		StateTree<JavaElement> value_generic_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("<")));
-		StateTree<JavaElement> value_generic_name = value_generic_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
-		StateTree<JavaElement> value_generic_split = value_generic_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
-		StateTree<JavaElement> value_generic_end = value_generic_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(">")));
-		value_generic_end.then(value_arg_begin);
-		value_generic_end.then(value_generic_name);
-		value_generic_end.then(value_generic_split);
-		value_generic_name.then(value_generic_begin);
-		value_generic_name.then(value_generic_end);
-		value_generic_split.then(value_generic_name);
-		StateTree<JavaElement> value_arg = value_arg_begin.then(new RedirectStateTree<>(value_container, (global, local) -> {
-			Integer count = global.get("args");
-			if(count == null) count = 0;
-			global.set("arg"+count, local);
-			global.set("args", (count+1));
-		}));
-		value_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
-			.then(value_arg);
-		value_arg.then(value_arg_end);
-		
-		StateTree<JavaElement> value_left = new StateTree<>();
-		
-		StateTree<JavaElement> value_parenthesis = value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
-		StateTree<JavaElement> value_cast = value_parenthesis.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
-			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
-			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
-		value_cast.then(value_left);
-		StateTree<JavaElement> value_lambda_arg = value_parenthesis.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
-		value_lambda_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
-			.then(value_lambda_arg);
-		StateTree<JavaElement> value_lambda = value_parenthesis.then((validator) ->
-			validator.validate((token) -> token.getValue().equals(")")) &&
-			validator.validate((token) -> token.getValue().equals("-")) &&
-			validator.validate((token) -> token.getValue().equals(">")));
-		value_lambda.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
-			.<JavaElement>end((a,bag) -> {
-				bag.set(new LambdaValue(null, new ArrayList<>()));
-				return a;
-			})
-			.multiple(function_container)
-			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
-		value_lambda.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("in", local.get()))).end((a,bag) ->{
-			bag.set(new LambdaValue(null, bag.<Value>get("in")));
-			return a;
-		});
-		value_lambda_arg.then(value_lambda);
-		StateTree<JavaElement> value_parenthesis_end = value_parenthesis.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("left", local.get())))
-			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
-		value_parenthesis_end.end();
-		value_parenthesis_end.then(value_call);
-		value_parenthesis_end.then(value_left);
-		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value_container);
-		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value_container);
-		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value_container);
-		value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
-		StateTree<JavaElement> value_inside = value_container.then(new RedirectStateTree<>(value, (global, local) -> {
-			global.set("left", local.get());
-		}));
-		value_inside.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
-			.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
-			.then((validator) -> validator.validate((token) -> token.getValue().equals("]")))
-			.then(value_left);
-		value_inside.then(value_left);
-		value_left.end((parent, bag) -> {
-			if(bag.get("left") instanceof Value) bag.set(bag.get("left"));
-			else bag.set(new Value(bag.<Token>get("left")));
-			return null;
-		});
-		StateTree<JavaElement> value_equals = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=")));
-		value_equals.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_minus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), (bag, token) -> bag.set("action", "<"))).loop();
-		value_minus.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_max = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), (bag, token) -> bag.set("action", ">"))).loop();
-		value_max.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("!")) && validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "!="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_or = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "|")));
-		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "||"))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_or.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_and = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&")));
-		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&&"))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_and.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_plus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "+")));
-		value_plus.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "++"))).end(value_builder);
-		StateTree<JavaElement> value_min = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "-")));
-		value_min.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "--"))).end(value_builder);
-		StateTree<JavaElement> value_div = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("/"), (bag, token) -> bag.set("action", "/")));
-		value_div.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_mod = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("%"), (bag, token) -> bag.set("action", "%")));
-		value_mod.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_xor = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("^"), (bag, token) -> bag.set("action", "^")));
-		value_xor.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		StateTree<JavaElement> value_mult = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("*"), (bag, token) -> bag.set("action", "*")));
-		value_mult.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
-		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
-			.then(new RedirectStateTree<>(value_container, value_right))
-			.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
-			.then(new RedirectStateTree<>(value_container, value_right))
-			.end(value_builder);
-		StateTree<JavaElement> value_instanceof = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("instanceof"), (bag, token) -> bag.set("action", "instanceof")))
-			.then(new RedirectStateTree<>(type, value_right));
-		value_instanceof.end(value_builder);
-		value_instanceof.then(value_left);
-		
-		braces_container.then(clazz_container);
-		StateTree<JavaElement> braces_array = braces_container.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
-		braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
-			.then(braces_array);
-		braces_array.end((a,b) -> a);
-	 
-	 
-	 
-	 
-	 
-	 * 
-	 * 
-	 * 
-	 */
 }

src/dev/peerat/parser/java/Operation.java

@@ -1,5 +1,38 @@
 package dev.peerat.parser.java;
 
+import java.util.function.Predicate;
+
+import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.java.Variable.VariableStreamable;
+import dev.peerat.parser.java.operation.AssignOperation;
+import dev.peerat.parser.java.operation.BreakOperation;
+import dev.peerat.parser.java.operation.CatchOperation;
+import dev.peerat.parser.java.operation.ContinueOperation;
+import dev.peerat.parser.java.operation.DoOperation;
+import dev.peerat.parser.java.operation.ElseOperation;
+import dev.peerat.parser.java.operation.FinallyOperation;
+import dev.peerat.parser.java.operation.ForOperation;
+import dev.peerat.parser.java.operation.ForeachOperation;
+import dev.peerat.parser.java.operation.IfOperation;
+import dev.peerat.parser.java.operation.MethodCallOperation;
+import dev.peerat.parser.java.operation.ReturnOperation;
+import dev.peerat.parser.java.operation.SwitchOperation;
+import dev.peerat.parser.java.operation.SynchronizedOperation;
+import dev.peerat.parser.java.operation.ThrowOperation;
+import dev.peerat.parser.java.operation.TryOperation;
+import dev.peerat.parser.java.operation.WhileOperation;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.InnerElementValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.Value.ValueStreamable;
+
 public abstract class Operation extends JavaElement{
 	
 	public static interface OperationContainer{
@@ -10,4 +43,46 @@ public abstract class Operation extends JavaElement{
 	
 	public Operation(){}
 	
+	public OperationStreamable stream(){
+		return new OperationStreamable();
+	}
+	
+	public class OperationStreamable implements TreeStreamable{
+		
+		public OperationStreamable(){}
+		
+		public OperationStreamable operationFilter(Predicate<Operation> filter){ return null; }
+		public OperationStreamable assignOperationFilter(Predicate<AssignOperation> filter){ return null; }
+		public OperationStreamable breakOperationFilter(Predicate<BreakOperation> filter){ return null; }
+		public OperationStreamable catchOperationFilter(Predicate<CatchOperation> filter){ return null; }
+		public OperationStreamable continueOperationFilter(Predicate<ContinueOperation> filter){ return null; }
+		public OperationStreamable doOperationFilter(Predicate<DoOperation> filter){ return null; }
+		public OperationStreamable elseOperationFilter(Predicate<ElseOperation> filter){ return null; }
+		public OperationStreamable finallyOperationFilter(Predicate<FinallyOperation> filter){ return null; }
+		public OperationStreamable foreachOperationFilter(Predicate<ForeachOperation> filter){ return null; }
+		public OperationStreamable forOperationFilter(Predicate<ForOperation> filter){ return null; }
+		public OperationStreamable ifOperationFilter(Predicate<IfOperation> filter){ return null; }
+		public OperationStreamable methodCallOperationFilter(Predicate<MethodCallOperation> filter){ return null; }
+		public OperationStreamable returnOperationFilter(Predicate<ReturnOperation> filter){ return null; }
+		public OperationStreamable switchOperationFilter(Predicate<SwitchOperation> filter){ return null; }
+		public OperationStreamable synchronizedOperationFilter(Predicate<SynchronizedOperation> filter){ return null; }
+		public OperationStreamable throwOperationFilter(Predicate<ThrowOperation> filter){ return null; }
+		public OperationStreamable tryOperationFilter(Predicate<TryOperation> filter){ return null; }
+		public OperationStreamable whileOperationFilter(Predicate<WhileOperation> filter){ return null; }
+		
+		public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
+		public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
+		public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
+		public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
+		public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
+		public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
+		public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
+		public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
+		public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
+		public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
+		
+		public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
+		
+	}
+
 }

src/dev/peerat/parser/java/Variable.java

@@ -3,11 +3,23 @@ package dev.peerat.parser.java;
 import java.lang.reflect.Modifier;
 import java.util.List;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.TokenType;
+import dev.peerat.parser.TreeStreamable;
 import dev.peerat.parser.java.Annotation.Annotable;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.InnerElementValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.Value.ValueStreamable;
 
 public class Variable extends Annotable{
 	
@@ -98,4 +110,24 @@ public class Variable extends Annotable{
 			value.findAll(finder, list);
 		}
 	}
+	
+	public VariableStreamable stream(){
+		return new VariableStreamable();
+	}
+
+	public class VariableStreamable implements TreeStreamable{
+		
+		public VariableStreamable(){}
+		
+		public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
+		public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
+		public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
+		public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
+		public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
+		public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
+		public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
+		public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
+		public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
+		public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
+	}
 }

src/dev/peerat/parser/java/value/BiValue.java

@@ -44,4 +44,8 @@ public class BiValue extends Value{
 		
 	}
 
+	@Override
+	public String toString(){
+		return "[BiValue] "+left+" "+action+" "+right;
+	}
 }

src/dev/peerat/parser/java/value/StaticValue.java

@@ -34,5 +34,8 @@ public class StaticValue extends Value{
 	}
 
 	
-	
+	@Override
+	public String toString(){
+		return "StaticValue["+token.getValue()+"]";
+	}
 }

src/dev/peerat/parser/java/value/Value.java

@@ -1,5 +1,28 @@
 package dev.peerat.parser.java.value;
 
+import java.util.function.Predicate;
+
 import dev.peerat.parser.java.JavaElement;
 
-public abstract class Value extends JavaElement{}
+public abstract class Value extends JavaElement{
+	
+	public ValueStreamable stream(){
+		return new ValueStreamable();
+	}
+	
+	public class ValueStreamable{
+		
+		public ValueStreamable(){}
+		
+		public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
+		public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
+		public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
+		public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
+		public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
+		public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
+		public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
+		public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
+		public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
+		public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
+	}
+}

src/dev/peerat/parser/state/RedirectStateTree.java

@@ -10,10 +10,18 @@ public class RedirectStateTree<E, T extends E> extends StateTree<T>{
 	private StateTree<E> redirect;
 	private BiConsumer<Bag, Bag> group;
 	
+	private StackTraceElement calling;
+
 	public RedirectStateTree(StateTree<E> redirect, BiConsumer<Bag, Bag> group){
 		super();
 		this.redirect = redirect;
 		this.group = group;
+		
+		StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+		int current = 0;
+		while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
+		
+		this.calling = trace[current];
 	}
 	
 	@Override
@@ -27,6 +35,8 @@ public class RedirectStateTree<E, T extends E> extends StateTree<T>{
 		if(builded == null) return null;
 		builded.build(branch, element);
 		
+		System.out.println("[redirect done] "+calling);
+
 		this.group.accept(currentBag, localBag);
 		branch.setBag(currentBag);
 		validator.merge(branch);

test/dev/peerat/parser/java/element/BaseElementTests.java

@@ -2,7 +2,9 @@ package dev.peerat.parser.java.element;
 
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
@@ -10,6 +12,7 @@ import java.util.function.Consumer;
 import org.junit.jupiter.api.Test;
 
 import dev.peerat.parser.Parser;
+import dev.peerat.parser.Token;
 import dev.peerat.parser.java.Class;
 import dev.peerat.parser.java.ClassBase;
 import dev.peerat.parser.java.Enumeration;
@@ -39,6 +42,7 @@ public class BaseElementTests{
 		try{
 			Parser<JavaElement> parser = new JavaParser();
 			for(int i = 0; i < size; i++){
+				System.out.printf("----------------------- Test %,4d ------------------------\n", (i+1));
 				JavaFile javaFile = new JavaFile();
 				parser.parse((text = texts.get(i)), javaFile);
 				checkers.get(i).accept(javaFile);
@@ -50,6 +54,36 @@ public class BaseElementTests{
 		}
 	}
 	
+	public void printObject(Object object){
+		try {
+			printObject(object, "");
+		}catch(Exception ex) {
+			ex.printStackTrace();
+		}
+	}
+	
+	private void printObject(Object object, String spaces) throws Exception{
+		System.out.println(spaces+"["+object.getClass()+"]");
+		for(Field field : object.getClass().getDeclaredFields()){
+			field.setAccessible(true);
+			System.out.println(spaces+" - "+field.getName());
+			Object value = field.get(object);
+			if(value == null) System.out.println(spaces+"\tnull");
+			else{
+				if(value.getClass().getPackage().getName().startsWith("java.lang") || value.getClass().isEnum()){
+					System.out.println(spaces+"\t"+value);
+					continue;
+				}
+				printObject(value, spaces+"\t");
+			}
+		}
+	}
+	
+	public void assertToken(String value, Token token){
+		assertNotNull(token);
+		assertEquals(value, token.getValue());
+	}
+
 	public Class checkClass(JavaFile javafile){
 		ClassBase clazzb = javafile.getMainClass();
 		assertNotNull(clazzb);

test/dev/peerat/parser/java/element/value/TypeOfValuesTests.java

@@ -0,0 +1,103 @@
+package dev.peerat.parser.java.element.value;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.Operation;
+import dev.peerat.parser.java.element.BaseElementTests;
+import dev.peerat.parser.java.operation.IfOperation;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.Value;
+
+public class TypeOfValuesTests extends BaseElementTests{
+	
+	{
+		register(
+				"package be.jeffcheasey88;"
+				+ ""
+				+ "public static class Test{ "
+				+ "    void test(){ "
+				+ "        if(a){}"
+				+ "}"
+				+ "}",
+				(javafile) -> {
+					StaticValue value = gotoValue(javafile);
+					assertToken("a", value.getToken());
+				});
+		
+		register(
+				"package be.jeffcheasey88;"
+				+ ""
+				+ "public static class Test{ "
+				+ "    void test(){ "
+				+ "        if(a > b){}"
+				+ "}"
+				+ "}",
+				(javafile) -> {
+					BiValue value = gotoValue(javafile);
+					StaticValue left = (StaticValue) value.left();
+					StaticValue right = (StaticValue) value.right(); //generic?
+					assertEquals("a", left.getToken().getValue());
+					assertEquals("b", right.getToken().getValue());
+					assertEquals(">", value.getAction());
+				});
+		
+		register(
+				"package be.jeffcheasey88;"
+				+ ""
+				+ "public static class Test{ "
+				+ "    void test(){ "
+				+ "        if(((a) > (b))){}"
+				+ "}"
+				+ "}",
+				(javafile) -> {
+					BiValue value = gotoValue(javafile);
+					StaticValue left = (StaticValue) value.left();
+					StaticValue right = (StaticValue) value.right(); //generic?
+					assertEquals("a", left.getToken().getValue());
+					assertEquals("b", right.getToken().getValue());
+					assertEquals(">", value.getAction());
+				});
+		
+		register(
+				"package be.jeffcheasey88;"
+				+ ""
+				+ "public static class Test{ "
+				+ "    void test(){ "
+				+ "        if(a && b == c){}"
+				+ "}"
+				+ "}",
+				(javafile) -> {
+					BiValue value = gotoValue(javafile);
+					printObject(value);
+					BiValue left = (BiValue) value.left();
+					StaticValue right = (StaticValue) value.right();
+					
+					StaticValue leftLeft = (StaticValue) left.left();
+					StaticValue leftRight = (StaticValue) left.right();
+					
+					assertToken("a", leftLeft.getToken());
+					assertEquals("&&", left.getAction());
+					assertToken("b", leftRight.getToken());
+					
+					assertEquals("==", value.getAction());
+					assertToken("c", right.getToken());
+				});
+	}
+	
+	private <T extends Value> T gotoValue(JavaFile javafile){
+		Function function = checkFunction(checkClass(javafile).getElements().get(0));
+		assertEquals(1, function.getElements().size());
+		Operation op = checkOperation(function.getElements().get(0));
+		assertTrue(op instanceof IfOperation);
+		IfOperation condition = (IfOperation)op;
+		Value value = condition.getCondition();
+		assertNotNull(value);
+		return (T) value;
+	}
+
+}