[BETA] Base Visitor System

src/dev/peerat/parser/StreamableTree.java

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

src/dev/peerat/parser/java/Annotation.java

@@ -7,6 +7,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Annotation extends JavaElement{
 	
@@ -135,4 +138,17 @@ public class Annotation extends JavaElement{
 			}
 		}
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		if(this.values != null)
+			for(Value value : this.values.values()){
+				bag.compute(value.visit(visitor).toList().toArray());
+			}
+		
+		return bag;
+	}
 }

src/dev/peerat/parser/java/AnnotationClass.java

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class AnnotationClass extends ClassBase{
 	
@@ -88,4 +91,18 @@ public class AnnotationClass extends ClassBase{
 			}
 		}
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		bag.compute(super.visit(visitor).toList().toArray());
+		
+		for(JavaElement element : this.elements){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
+		
+		return bag;
+	}
 }

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

@@ -2,12 +2,11 @@ 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.StreamableTree;
+import dev.peerat.parser.java.visitor.JavaVisitor;
-import dev.peerat.parser.java.Function.FunctionStreamable;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
-import dev.peerat.parser.java.Variable.VariableStreamable;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Class extends ClassBase{
 	
@@ -107,23 +106,18 @@ public class Class extends ClassBase{
 			}
 		}
 	}
-	
-	public ClassStreamable stream(){
-		return new ClassStreamable();
-	}
 
-	public class ClassStreamable implements StreamableTree{
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
 		
-		public ClassStreamable(){}
+		bag.compute(super.visit(visitor).toList().toArray());
 		
-		public FunctionStreamable functionFilter(Predicate<Function> filter){ return null; }
+		for(JavaElement element : this.elements){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
 		
-		public FunctionStreamable constructorFilter(Predicate<Function> filter){ return null; }
+		return bag;
-		
-		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/ClassBase.java

@@ -7,6 +7,9 @@ import dev.peerat.parser.java.Annotation.Annotable;
 import dev.peerat.parser.java.Annotation.AnnotableBuffer;
 import dev.peerat.parser.java.Function.FunctionContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 
 public abstract class ClassBase extends Annotable implements AnnotableBuffer, ClassContainer, FunctionContainer, VariableContainer{
@@ -28,4 +31,15 @@ public abstract class ClassBase extends Annotable implements AnnotableBuffer, Cl
 		this.annotationBuffer = null;
 		return list;
 	}
+	
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		VisitorBag bag = new ListVisitorBag();
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.compute(annotation.visit(visitor).toList().toArray());
+			}
+		return bag;
+	}
 }

src/dev/peerat/parser/java/Enumeration.java

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Enumeration extends ClassBase{
 	
@@ -94,4 +97,18 @@ public class Enumeration extends ClassBase{
 		}
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		bag.compute(super.visit(visitor).toList().toArray());
+		
+		for(JavaElement element : this.elements){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
+		
+		return bag;
+	}
+
 }

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

@@ -3,15 +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 dev.peerat.parser.Token;
 import dev.peerat.parser.TokenType;
-import dev.peerat.parser.StreamableTree;
 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;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Function extends Annotable implements VariableContainer, OperationContainer{
 	
@@ -161,14 +161,26 @@ public class Function extends Annotable implements VariableContainer, OperationC
 		}
 	}
 	
-	public FunctionStreamable stream(){
+	@Override
-		return new FunctionStreamable();
+	public VisitorBag visit(JavaVisitor<?> visitor) {
-	}
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
-
+		VisitorBag bag = new ListVisitorBag();
-	public class FunctionStreamable implements StreamableTree{
 		
-		public FunctionStreamable(){}
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.compute(annotation.visit(visitor).toList().toArray());
+			}
 		
-		public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
+		if(this.parameters != null)
+			for(Variable variable : this.parameters){
+				bag.compute(variable.visit(visitor).toList().toArray());
+			}
+		
+		for(JavaElement element : this.elements){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
+		
+		return bag;
 	}
 }

src/dev/peerat/parser/java/Import.java

@@ -1,8 +1,14 @@
 package dev.peerat.parser.java;
 
-import dev.peerat.parser.Token;
+import java.util.List;
+import java.util.function.Function;
 
-public class Import{
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
+public class Import extends JavaElement{
 	
 	private boolean isStatic;
 	private Token value;
@@ -20,4 +26,25 @@ public class Import{
 		return this.value;
 	}
 
+	@Override
+	public void build(Builder builder) throws Exception {
+		
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder) {
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
+		
+	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
+
 }

src/dev/peerat/parser/java/Interface.java

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Interface extends ClassBase{
 	
@@ -93,4 +96,16 @@ public class Interface extends ClassBase{
 			}
 		}
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		bag.compute(super.visit(visitor).toList().toArray());
+		
+		for(JavaElement element : this.elements) bag.compute(element.visit(visitor).toList().toArray());
+		
+		return bag;
+	}
 }

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

@@ -4,10 +4,14 @@ import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.ElementBuilder;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
-public abstract class JavaElement implements ElementBuilder{	
+public abstract class JavaElement implements ElementBuilder{
 	
 	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);
-}
+
+	public abstract VisitorBag visit(JavaVisitor<?> visitor);
+}

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

@@ -7,6 +7,9 @@ import java.util.function.Function;
 import dev.peerat.parser.Bag;
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class JavaFile extends JavaElement implements ClassContainer, AnnotableBuffer{
 	
@@ -102,5 +105,25 @@ public class JavaFile extends JavaElement implements ClassContainer, AnnotableBu
 			clazz.findAll(finder, list);
 		}
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		if(this.imports != null)
+			for(Import imp : this.imports){
+				bag.compute(imp.visit(visitor).toList().toArray());
+			}
+		
+		bag.compute(mainClazz.visit(visitor).toList().toArray());
+		
+		if(this.subClazz != null)
+			for(ClassBase clazz : this.subClazz){
+				bag.compute(clazz.visit(visitor).toList().toArray());
+			}
+		
+		return bag;
+	}
 	
 }

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

@@ -1,37 +1,5 @@
 package dev.peerat.parser.java;
 
-import java.util.function.Predicate;
-
-import dev.peerat.parser.StreamableTree;
-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.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{
@@ -42,45 +10,5 @@ public abstract class Operation extends JavaElement{
 	
 	public Operation(){}
 	
-	public OperationStreamable stream(){
-		return new OperationStreamable();
-	}
-	
-	public class OperationStreamable implements StreamableTree{
-		
-		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 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,23 +3,14 @@ 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.StreamableTree;
 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;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class Variable extends Annotable{
 	
@@ -111,23 +102,20 @@ public class Variable extends Annotable{
 		}
 	}
 	
-	public VariableStreamable stream(){
+	@Override
-		return new VariableStreamable();
+	public VisitorBag visit(JavaVisitor<?> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.compute(annotation.visit(visitor).toList().toArray());
+			}
+		
+		if(this.value != null) bag.compute(this.value.visit(visitor).toList().toArray());
+		
+		return bag;
 	}
 
-	public class VariableStreamable implements StreamableTree{
-		
-		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/operation/AssignOperation.java

@@ -6,6 +6,9 @@ import java.util.function.Function;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class AssignOperation extends Operation{
 	
@@ -44,4 +47,13 @@ public class AssignOperation extends Operation{
 		if(finder.apply(right)) list.add((E) right);
 		right.findAll(finder, list);
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(left.visit(visitor).toList().toArray());
+		bag.compute(right.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/BreakOperation.java

@@ -5,6 +5,8 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class BreakOperation extends Operation{
 	
@@ -23,4 +25,10 @@ public class BreakOperation extends Operation{
 	@Override
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
+
 }

src/dev/peerat/parser/java/operation/CatchOperation.java

@@ -3,6 +3,8 @@ package dev.peerat.parser.java.operation;
 import java.util.List;
 
 import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class CatchOperation extends OperationBag{
 	
@@ -28,4 +30,10 @@ public class CatchOperation extends OperationBag{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+
 }

src/dev/peerat/parser/java/operation/ContinueOperation.java

@@ -5,6 +5,8 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ContinueOperation extends Operation{
 	
@@ -20,4 +22,10 @@ public class ContinueOperation extends Operation{
 
 	@Override
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
 }

src/dev/peerat/parser/java/operation/DoOperation.java

@@ -1,5 +1,8 @@
 package dev.peerat.parser.java.operation;
 
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
 public class DoOperation extends OperationBag{
 
 	@Override
@@ -7,4 +10,10 @@ public class DoOperation extends OperationBag{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+
 }

src/dev/peerat/parser/java/operation/ElseOperation.java

@@ -1,5 +1,8 @@
 package dev.peerat.parser.java.operation;
 
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
 public class ElseOperation extends OperationBag{
 
 	@Override
@@ -7,4 +10,10 @@ public class ElseOperation extends OperationBag{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+
 }

src/dev/peerat/parser/java/operation/FinallyOperation.java

@@ -1,5 +1,8 @@
 package dev.peerat.parser.java.operation;
 
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
 public class FinallyOperation extends OperationBag{
 
 	@Override
@@ -7,4 +10,10 @@ public class FinallyOperation extends OperationBag{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+
 }

src/dev/peerat/parser/java/operation/ForOperation.java

@@ -6,6 +6,9 @@ import java.util.function.Function;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Variable;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ForOperation extends OperationBag{
 	
@@ -91,4 +94,29 @@ public class ForOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		if(init_vars != null)
+			for(Variable variable : this.init_vars){
+				bag.compute(variable.visit(visitor).toList().toArray());
+			}
+		
+		if(init_values != null)
+			for(Value value : this.init_values){
+				bag.compute(value.visit(visitor).toList().toArray());
+			}
+		
+		bag.compute(condition.visit(visitor).toList().toArray());
+		
+		if(this.updates != null)
+			for(Value value : this.updates){
+				bag.compute(value.visit(visitor).toList().toArray());
+			}
+		
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/ForeachOperation.java

@@ -6,6 +6,9 @@ import java.util.function.Function;
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ForeachOperation extends OperationBag{
 	
@@ -50,4 +53,13 @@ public class ForeachOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.iterator.visit(visitor).toList().toArray());
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/IfOperation.java

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class IfOperation extends OperationBag{
 	
@@ -36,4 +39,13 @@ public class IfOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(condition.visit(visitor).toList().toArray());
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/OperationBag.java

@@ -9,6 +9,9 @@ import dev.peerat.parser.java.Operation;
 import dev.peerat.parser.java.Variable;
 import dev.peerat.parser.java.Operation.OperationContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public abstract class OperationBag extends Operation implements VariableContainer, OperationContainer{
 
@@ -51,5 +54,14 @@ public abstract class OperationBag extends Operation implements VariableContaine
 			}
 		}
 	}
+	
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor){
+		VisitorBag bag = new ListVisitorBag();
+		for(JavaElement element : this.elements){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
+		return bag;
+	}
 
 }

src/dev/peerat/parser/java/operation/ReturnOperation.java

@@ -6,6 +6,9 @@ import java.util.function.Function;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ReturnOperation extends Operation{
 	
@@ -36,4 +39,12 @@ public class ReturnOperation extends Operation{
 			value.findAll(finder, list);
 		}
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		if(this.value != null) bag.compute(this.value.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/SwitchOperation.java

@@ -5,9 +5,13 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class SwitchOperation extends Operation{
 	
+	//+ AND OBJECT FOR CONTAINING EVERY CASE OP
+	
 	@Override
 	public void build(Builder builder) throws Exception{
 	}
@@ -19,4 +23,10 @@ public class SwitchOperation extends Operation{
 
 	@Override
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
 }

src/dev/peerat/parser/java/operation/SynchronizedOperation.java

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class SynchronizedOperation extends OperationBag{
 	
@@ -36,4 +39,13 @@ public class SynchronizedOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.value.visit(visitor).toList().toArray());
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/ThrowOperation.java

@@ -6,6 +6,9 @@ import java.util.function.Function;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Operation;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ThrowOperation extends Operation{
 	
@@ -36,4 +39,12 @@ public class ThrowOperation extends Operation{
 		value.findAll(finder, list);
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.value.visit(visitor).toList().toArray());
+		return bag;
+	}
+
 }

src/dev/peerat/parser/java/operation/TryOperation.java

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class TryOperation extends OperationBag{
 
@@ -41,4 +44,13 @@ public class TryOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		if(this.resource != null) bag.compute(this.resource.visit(visitor).toList().toArray());
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/operation/WhileOperation.java

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class WhileOperation extends OperationBag{
 	
@@ -35,4 +38,13 @@ public class WhileOperation extends OperationBag{
 	public void build(Builder builder) throws Exception {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.condition.visit(visitor).toList().toArray());
+		bag.compute(super.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

src/dev/peerat/parser/java/tree/ValueTree.java

@@ -6,6 +6,7 @@ import dev.peerat.parser.Bag;
 import dev.peerat.parser.TokenType;
 import dev.peerat.parser.java.JavaElement;
 import dev.peerat.parser.java.value.BiValue;
+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;
@@ -67,6 +68,14 @@ public class ValueTree extends SyntaxTree<JavaElement> {
 			return null;
 		};
 		
+		BiFunction<JavaElement, Bag, JavaElement> methodCallValueBuilder = (parent, bag) -> {
+			System.out.println("methodCallValueBuilder "+bag);
+			MethodCallValue result = new MethodCallValue(null, null, bag.get("current"), null);
+			bag.set(result);
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(result);
+			return null;
+		};
+		
 		StateTree<JavaElement> redirectRight = new RedirectStateTree<>(value, (global, local) -> {
 			System.out.println("redirectRight g="+global+" ,l="+local);
 			global.set("right", local.get());
@@ -147,7 +156,7 @@ public class ValueTree extends SyntaxTree<JavaElement> {
 		StateTree<JavaElement> operation_begin = value_name.equals("(");
 		StateTree<JavaElement> operation_end = operation_begin.equals(")");
 		operation_end.then(operation_call);
-		operation_end.end();
+		operation_end.end(methodCallValueBuilder);
 		StateTree<JavaElement> operation_value = operation_begin.redirect(value);
 		operation_value.then(operation_end);
 		operation_value.equals(",")

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

@@ -4,6 +4,9 @@ import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ArrayValue extends Value{
 	
@@ -31,6 +34,16 @@ public class ArrayValue extends Value{
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		for(Value value : this.values){
+			bag.compute(value.visit(visitor).toList().toArray());
+		}
+		return bag;
+	}
 	
 	
 

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

@@ -4,6 +4,9 @@ import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class BiValue extends Value{
 	
@@ -48,4 +51,13 @@ public class BiValue extends Value{
 	public String toString(){
 		return "[BiValue] "+left+" "+action+" "+right;
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(left.visit(visitor).toList().toArray());
+		bag.compute(right.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

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

@@ -4,6 +4,9 @@ import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class InnerElementValue extends Value{
 	
@@ -32,6 +35,14 @@ public class InnerElementValue extends Value{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.element.visit(visitor).toList().toArray());
+		return bag;
+	}
+
 	
 	
 }

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

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class InstanceValue extends Value{
 	
@@ -45,4 +48,15 @@ public class InstanceValue extends Value{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		if(this.parameters != null)
+			for(Value value : this.parameters){
+				bag.compute(value.visit(visitor).toList().toArray());
+			}
+		return bag;
+	}
+
 }

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

@@ -10,6 +10,9 @@ import dev.peerat.parser.java.Operation;
 import dev.peerat.parser.java.Variable;
 import dev.peerat.parser.java.Operation.OperationContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class LambdaValue extends Value implements OperationContainer, VariableContainer{
 	
@@ -59,6 +62,16 @@ public class LambdaValue extends Value implements OperationContainer, VariableCo
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
 		
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		for(JavaElement element : this.operations){
+			bag.compute(element.visit(visitor).toList().toArray());
+		}
+		return bag;
+	}
 	
 
 }

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

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class MethodCallValue extends Value{
 	
@@ -51,4 +54,16 @@ public class MethodCallValue extends Value{
 		
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.base.visit(visitor).toList().toArray());
+		if(this.parameters != null)
+			for(Value value : this.parameters){
+				bag.compute(value.visit(visitor).toList().toArray());
+			}
+		return bag;
+	}
+
 }

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

@@ -5,6 +5,9 @@ import java.util.function.Function;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class ModifierValue extends Value{
 
@@ -43,4 +46,12 @@ public class ModifierValue extends Value{
 	public String toString(){
 		return "[ModifierValue] "+modifier+value;
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(value.visit(visitor).toList().toArray());
+		return bag;
+	}
 }

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

@@ -5,6 +5,8 @@ import java.util.function.Function;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class StaticValue extends Value{
 	
@@ -38,4 +40,10 @@ public class StaticValue extends Value{
 	public String toString(){
 		return "StaticValue["+token.getValue()+"]";
 	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
 }

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

@@ -4,6 +4,9 @@ import java.util.List;
 import java.util.function.Function;
 
 import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
 
 public class TriValue extends Value{
 	
@@ -49,4 +52,16 @@ public class TriValue extends Value{
 		return "[TriValue] "+check+" ? "+success+" : "+fail;
 	}
 
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		
+		bag.compute(this.check.visit(visitor).toList().toArray());
+		bag.compute(this.success.visit(visitor).toList().toArray());
+		bag.compute(this.fail.visit(visitor).toList().toArray());
+		
+		return bag;
+	}
+
 }

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

@@ -1,7 +1,5 @@
 package dev.peerat.parser.java.value;
 
-import java.util.function.Predicate;
-
 import dev.peerat.parser.java.JavaElement;
 
 public abstract class Value extends JavaElement{
@@ -13,23 +11,4 @@ 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/java/value/VariableAccessValue.java

@@ -0,0 +1,55 @@
+package dev.peerat.parser.java.value;
+
+import java.util.List;
+import java.util.function.Function;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
+public class VariableAccessValue extends Value{
+
+	private Value base;
+	private Token variable;
+	
+	public VariableAccessValue(Value base, Token variable){
+		this.base = base;
+		this.variable = variable;
+	}
+	
+	public Value base(){
+		return this.base;
+	}
+	
+	public Token getVariable(){
+		return this.variable;
+	}
+	
+	@Override
+	public void build(Builder builder) throws Exception {
+		
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder) {
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
+		
+	}
+
+	@Override
+	public VisitorBag visit(JavaVisitor<?> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new ListVisitorBag();
+		bag.compute(this.base.visit(visitor).toList().toArray());
+		return bag;
+	}
+
+	
+	
+}

src/dev/peerat/parser/java/visitor/JavaAnnotationVisitor.java

@@ -0,0 +1,66 @@
+package dev.peerat.parser.java.visitor;
+
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.visitor.bag.ListVisitorBag;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
+public class JavaAnnotationVisitor extends JavaVisitor<Annotation>{
+	
+	private Predicate<String> nameFilter;
+	private Predicate<String> keyFilter;
+	private BiPredicate<String, Value> valueFilter; 
+
+	public JavaAnnotationVisitor(){
+		super(Annotation.class);
+	}
+	
+	public JavaAnnotationVisitor filterName(Predicate<String> validator){
+		this.nameFilter = (this.nameFilter == null) ? validator : this.nameFilter.and(validator);
+		return this;
+	}
+	
+	public JavaAnnotationVisitor hasKey(Predicate<String> validator){
+		this.keyFilter = (this.keyFilter == null) ? validator : this.keyFilter.and(validator);
+		return this;
+	}
+	
+	public JavaAnnotationVisitor filterValue(BiPredicate<String, Value> validator){
+		this.valueFilter = (this.valueFilter == null) ? validator : this.valueFilter.and(validator);
+		return this;
+	}
+	
+	@Override
+	public VisitorBag visitElement(Annotation element){
+		VisitorBag bag = new ListVisitorBag();
+		if(nameFilter != null){
+			if(!nameFilter.test(element.getName().getValue())) return bag;
+		}
+		
+		if(keyFilter != null){
+			Map<Token, Value> paramters = element.getParameters();
+			if(paramters == null) return bag;
+			for(Token token : paramters.keySet()){
+				if(!keyFilter.test(token.getValue())) return bag;
+			}
+		}
+		
+		if(valueFilter != null){
+			Map<Token, Value> paramters = element.getParameters();
+			if(paramters == null) return bag;
+			for(Entry<Token, Value> entry : paramters.entrySet()){
+				if(!valueFilter.test(entry.getKey().getValue(), entry.getValue())) return bag;
+			}
+		}
+		
+		bag.compute(element);
+		return bag;
+	}
+	
+}

src/dev/peerat/parser/java/visitor/JavaVisitor.java

@@ -0,0 +1,83 @@
+package dev.peerat.parser.java.visitor;
+
+import dev.peerat.parser.java.AnnotationClass;
+import dev.peerat.parser.java.ClassBase;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.Import;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Operation;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.bag.VisitorBag;
+
+public abstract class JavaVisitor<T extends JavaElement> extends Visitor<JavaElement>{
+	
+	public static <T extends JavaElement>  JavaVisitor<T> base(JavaVisitor<T> visitor){
+		return visitor;
+	}
+
+	public static JavaVisitor<JavaElement> allJavaElement(){
+		return null;
+	}
+	
+	public static JavaVisitor<ClassBase> allClassBase(){
+		return null;
+	}
+	
+	public static JavaVisitor<dev.peerat.parser.java.Class> allClass(){
+		return null;
+	}
+	
+	public static JavaVisitor<JavaElement> allInterface(){
+		return null;
+	}
+	
+	public static JavaVisitor<JavaElement> allEnum(){
+		return null;
+	}
+	
+	public static JavaVisitor<AnnotationClass> allAnnotationClass(){
+		return null;
+	}
+	
+	public static JavaAnnotationVisitor allAnnotation(){
+		return new JavaAnnotationVisitor();
+	}
+	
+	public static JavaVisitor<Variable> allVariable(){
+		return null;
+	}
+	
+	public static JavaVisitor<Function> allFunction(){
+		return null;
+	}
+	
+	public static JavaVisitor<Value> allValue(){
+		return null;
+	}
+	
+	public static JavaVisitor<Operation> allOperation(){
+		return null;
+	}
+	
+	public static JavaVisitor<Import> allImport(){
+		return null;
+	}
+	
+	private Class<?> type;
+	
+	JavaVisitor(Class<?> type){
+		this.type = type;
+	}
+	
+	public boolean canVisit(Class<?> type){
+		return this.type.isAssignableFrom(type);
+	}
+	
+	public VisitorBag visit(Object element){
+		return visitElement((T) element);
+	}
+	
+	public abstract VisitorBag visitElement(T element);
+}

src/dev/peerat/parser/java/visitor/internal/chain/JavaVisitorChain.java

@@ -0,0 +1,22 @@
+package dev.peerat.parser.java.visitor.internal.chain;
+
+import dev.peerat.parser.java.JavaElement;
+
+public abstract class JavaVisitorChain<T extends JavaElement>{
+	
+	private JavaVisitorChain<?> next;
+	
+	public JavaVisitorChain<?> chain(JavaVisitorChain<?> next){
+		return this.next = next;
+	}
+	
+	public JavaVisitorChain<?> chain(){
+		return this.next;
+	}
+	
+	public boolean hasNext(){
+		return this.next != null;
+	}
+	
+	public abstract boolean visit(T element);
+}

src/dev/peerat/parser/java/visitor/internal/chain/JavaVisitorChainPredicate.java

@@ -0,0 +1,25 @@
+package dev.peerat.parser.java.visitor.internal.chain;
+
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+
+public class JavaVisitorChainPredicate<T extends JavaElement> extends JavaVisitorChain<T>{
+
+	private Predicate<T> predicate;
+	
+	public JavaVisitorChainPredicate(Predicate<T> predicate){
+		this.predicate = predicate;
+	}
+
+	@Override
+	public boolean visit(T element){
+//		if(this.predicate.test(element)){
+//			if(hasNext()) return chain().visit(element);
+//			else return true;
+//		}else return false;
+		return false;
+	}
+	
+	
+}

src/dev/peerat/parser/visitor/Example.java

@@ -0,0 +1,37 @@
+package dev.peerat.parser.visitor;
+
+import static dev.peerat.parser.java.visitor.JavaVisitor.allAnnotation;
+
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.JavaParser;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+
+public class Example { 
+	
+	public static void main(String[] args) throws Exception{
+		
+		JavaParser parser = new JavaParser();
+		JavaFile container = new JavaFile();
+		parser.parse("package be.peerat.test; public class Example{ @Test public void helloTest(){} }", container);
+		
+//		JavaVisitor visitor = JavaVisitor.base(
+//				key(
+//						allJavaElement()
+//				),
+//				value(
+//						allAnnotation().filterName((name) -> name.equals("Test"))
+//				)
+//		);
+		
+		JavaVisitor<Annotation> visitor = JavaVisitor.base(
+				allAnnotation().filterName((name) -> name.equals("Test"))
+		);
+		
+		Function func = container.getMainClass().find((element) -> element instanceof Function);
+		System.out.println("1. "+func.visit(visitor).toList());
+		System.out.println("2. "+container.visit(visitor).toList());
+	}
+
+}

src/dev/peerat/parser/visitor/Operator.java

@@ -0,0 +1,21 @@
+package dev.peerat.parser.visitor;
+
+public class Operator{
+	
+	public static <T extends Visitor<?>> T and(Visitor<?>... visitors){
+		return null;
+	}
+	
+	public static <T extends Visitor<?>> T or(Visitor<?>... visitors){
+		return null;
+	}
+	
+	public static <T extends Visitor<?>> T key(Visitor<?> visitor){
+		return null;
+	}
+	
+	public static <T extends Visitor<?>> T value(Visitor<?> visitor){
+		return null;
+	}
+
+}

src/dev/peerat/parser/visitor/Visitor.java

@@ -0,0 +1,5 @@
+package dev.peerat.parser.visitor;
+
+public abstract class Visitor<T>{
+	
+}

src/dev/peerat/parser/visitor/bag/ListVisitorBag.java

@@ -0,0 +1,29 @@
+package dev.peerat.parser.visitor.bag;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListVisitorBag extends VisitorBag{
+
+	private List<Object> list;
+	
+	public ListVisitorBag(){
+		this.list = new ArrayList<>();
+	}
+	
+	@Override
+	public void compute(Object... elements) {
+		for(Object element : elements) list.add(element);
+	}
+
+	@Override
+	public <T> T toElement(){
+		return (T) list.get(0);
+	}
+
+	@Override
+	public <T> List<T> toList(){
+		return (List<T>) list;
+	}
+
+}

src/dev/peerat/parser/visitor/bag/VisitorBag.java

@@ -0,0 +1,12 @@
+package dev.peerat.parser.visitor.bag;
+
+import java.util.List;
+
+public abstract class VisitorBag{
+
+	public abstract void compute(Object... elements);
+	
+	public abstract <T> T toElement();
+	
+	public abstract <T> List<T> toList();
+}

test/SpecificCase.java

@@ -0,0 +1,39 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+
+import org.junit.jupiter.api.Test;
+
+import dev.peerat.parser.Parser;
+import dev.peerat.parser.TokenValidator;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.JavaParser;
+
+public class SpecificCase{
+	
+	@Test
+	void genericInMethod() throws Exception{
+		String clazz = "class Test{ <T> T testIt(){ return (T)null; } }";
+		Parser<JavaElement> parser = new JavaParser();
+		
+		BufferedReader reader = new BufferedReader(new Reader() {
+			public int read(char[] cbuf, int off, int len) throws IOException {return 0;}
+			public void close() throws IOException {}
+		}){
+			String line = clazz;
+			@Override
+			public String readLine() throws IOException{
+				String value = line;
+				line = null;
+				return value;
+			}
+		};
+		parser.parse(reader, new JavaFile());
+		parser.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
+	}
+
+}

test/dev/peerat/parser/java/ValueTypesTests.java

@@ -0,0 +1,186 @@
+package dev.peerat.parser.java;
+
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+import java.util.function.Function;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+
+import dev.peerat.parser.Parser;
+import dev.peerat.parser.java.tree.JavaTreeType;
+import dev.peerat.parser.java.value.BiValue;
+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.ValueContainer;
+
+@TestInstance(Lifecycle.PER_CLASS)
+public class ValueTypesTests {
+	
+	private Parser<JavaElement> parser;
+	
+	@BeforeAll
+	public void init(){
+		parser = new JavaParser(JavaTreeType.VALUE);
+	}
+	
+	private Value parse(String value) throws Exception{
+		Container container = new Container();
+		parser.parse(value, container);
+		return container.getValue();
+	}
+	
+	private static class Container extends JavaElement implements ValueContainer{
+		
+		private Value value;
+		
+		@Override
+		public void addValue(Value value) {
+			this.value = value;
+		}
+		
+		public Value getValue(){
+			return this.value;
+		}
+
+		@Override
+		public void build(Builder builder) throws Exception {}
+
+		@Override
+		public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){return null;}
+
+		@Override
+		public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){}
+		
+	}
+	
+	private <T> T assertInstance(Object obj, java.lang.Class<? extends T> type){
+		assertTrue(type.isAssignableFrom(obj.getClass()));
+		return (T) obj;
+	}
+
+	@Test
+	public void onStaticValue() throws Exception{
+		
+		//ALL FORMATED VALUES LIKE DOUBLE, FLOAT, BINARY, CHARS(?),.....
+		
+		StaticValue v;
+		
+		v = assertInstance(parse("8"), StaticValue.class);
+		assertEquals("8", v.getToken().getValue());		
+		v = assertInstance(parse("value"), StaticValue.class);
+		assertEquals("value", v.getToken().getValue());	
+		v = assertInstance(parse("\"value\""), StaticValue.class);
+		assertEquals("\"value\"", v.getToken().getValue());
+		v = assertInstance(parse("'a'"), StaticValue.class);
+		assertEquals("'a'", v.getToken().getValue());
+	}
+	
+	@Test
+	public void onBiValue() throws Exception{
+		
+		BiValue v;
+		
+		v = assertInstance(parse("8+8"), BiValue.class);
+		assertEquals("8", assertInstance(v.left(), StaticValue.class).getToken().getValue());
+		assertEquals("+", v.getAction());
+		assertEquals("8", assertInstance(v.right(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("8+offset"), BiValue.class);
+		assertEquals("8", assertInstance(v.left(), StaticValue.class).getToken().getValue());
+		assertEquals("+", v.getAction());
+		assertEquals("offset", assertInstance(v.right(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("8+offset > 8"), BiValue.class);
+		BiValue right = assertInstance(v.right(), BiValue.class);
+		assertEquals("8", assertInstance(v.left(), StaticValue.class).getToken().getValue());
+		assertEquals("+", v.getAction());
+		assertEquals("offset", assertInstance(right.left(), StaticValue.class).getToken().getValue());
+		assertEquals(">", right.getAction());
+		assertEquals("8", assertInstance(right.right(), StaticValue.class).getToken().getValue());
+	}
+	
+	@Test
+	public void onTriValue() throws Exception{
+		
+		TriValue v;
+		
+		v = assertInstance(parse("bool ? true : false"), TriValue.class);
+		assertEquals("bool", assertInstance(v.getChecker(), StaticValue.class).getToken().getValue());
+		assertEquals("true", assertInstance(v.success(), StaticValue.class).getToken().getValue());
+		assertEquals("false", assertInstance(v.fail(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("bool ? 8+8 : false"), TriValue.class);
+		assertEquals("bool", assertInstance(v.getChecker(), StaticValue.class).getToken().getValue());
+		BiValue bv = assertInstance(v.success(), BiValue.class);
+		assertEquals("8", assertInstance(bv.left(), StaticValue.class).getToken().getValue());
+		assertEquals("+", bv.getAction());
+		assertEquals("8", assertInstance(bv.right(), StaticValue.class).getToken().getValue());
+		assertEquals("false", assertInstance(v.fail(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("bool ? rebool ? true : bool : false"), TriValue.class);
+		assertEquals("bool", assertInstance(v.getChecker(), StaticValue.class).getToken().getValue());
+		assertEquals("false", assertInstance(v.fail(), StaticValue.class).getToken().getValue());
+		TriValue success = assertInstance(v.success(), TriValue.class);
+		assertEquals("rebool", assertInstance(success.getChecker(), StaticValue.class).getToken().getValue());
+		assertEquals("true", assertInstance(success.success(), StaticValue.class).getToken().getValue());
+		assertEquals("bool", assertInstance(success.fail(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("(rebool ? true : bool) ? true : false"), TriValue.class);
+		TriValue checker = assertInstance(v.getChecker(), TriValue.class);
+		assertEquals("rebool", assertInstance(checker.getChecker(), StaticValue.class).getToken().getValue());
+		assertEquals("true", assertInstance(checker.success(), StaticValue.class).getToken().getValue());
+		assertEquals("bool", assertInstance(checker.fail(), StaticValue.class).getToken().getValue());
+		assertEquals("true", assertInstance(v.success(), StaticValue.class).getToken().getValue());
+		assertEquals("false", assertInstance(v.fail(), StaticValue.class).getToken().getValue());
+	}
+	
+	@Test
+	public void onModifierValue() throws Exception{
+		
+		ModifierValue v;
+		v = assertInstance(parse("!a"), ModifierValue.class);
+		assertEquals("!", v.getModifier().getValue());
+		assertEquals("a", assertInstance(v.getValue(), StaticValue.class).getToken().getValue());
+		
+		v = assertInstance(parse("!(a || b)"), ModifierValue.class);
+		assertEquals("!", v.getModifier().getValue());
+		BiValue bv = assertInstance(v.getValue(), BiValue.class);
+		assertEquals("a", assertInstance(bv.left(), StaticValue.class).getToken().getValue());
+		assertEquals("||", bv.getAction());
+		assertEquals("b", assertInstance(bv.right(), StaticValue.class).getToken().getValue());
+	}
+	
+	@Test
+	public void onMethodCallValue() throws Exception{
+		MethodCallValue v;
+		v = assertInstance(parse("test()"), MethodCallValue.class);
+		assertNull(v.base());
+		assertEquals("test", v.getToken().getValue());
+		assertNull(v.getGeneric());
+		assertNull(v.getParameters());
+		
+		v = assertInstance(parse("JavaParserTest.test(8+8).equals(16)"), MethodCallValue.class);
+		assertEquals("equals", v.getToken().getValue());
+		assertEquals(1, v.getParameters().size());
+		assertEquals("16", assertInstance(v.getParameters().get(0), StaticValue.class).getToken().getValue());
+		v = assertInstance(v.base(), MethodCallValue.class);
+		assertEquals(1, v.getParameters().size());
+		BiValue bv = assertInstance(v.getParameters().get(0), BiValue.class);
+		assertEquals("8", assertInstance(bv.left(), StaticValue.class).getToken().getValue());
+		assertEquals("+", bv.getAction());
+		assertEquals("8", assertInstance(bv.right(), StaticValue.class).getToken().getValue());
+		assertEquals("test", v.getToken().getValue());
+		assertEquals("JavaParserTest", assertInstance(v.base(), StaticValue.class).getToken().getClass());
+		
+		v = assertInstance(parse("main.test.here.localvar.run(6)[0].validate(7)"), MethodCallValue.class);
+	}
+}

test/dev/peerat/parser/java/browser/BrowserLambdaTests.java

@@ -0,0 +1,77 @@
+package dev.peerat.parser.java.browser;
+
+import java.lang.reflect.Modifier;
+
+import org.junit.jupiter.api.Test;
+
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.JavaParser;
+import dev.peerat.parser.java.Class;
+
+public class BrowserLambdaTests{
+	
+	@Test
+	void main(){
+		
+		try{
+			JavaParser parser = new JavaParser();
+			JavaFile javaFile = new JavaFile();
+			parser.parse("package be.jeffcheasey88; public class Test{ public Test(){} public void test(){} }", javaFile);
+
+			
+			Class clazz = (Class) javaFile.getMainClass();
+			System.out.println(clazz);
+			clazz.stream().functionFilter((func) -> func.getName().getValue().equals("test"));
+		}catch(Exception ex){
+			ex.printStackTrace();
+		}
+		
+	}
+	
+	@Test
+	void findVariableGetterSetter(){
+		try{
+			JavaParser parser = new JavaParser();
+			JavaFile javaFile = new JavaFile();
+			parser.parse("package be.jeffcheasey88; public class Test{ private boolean isActive; public boolean isActive(){ return isActive;} public void setActive(boolean active){ isActive = active; } }", javaFile);
+
+			
+			Class clazz = (Class) javaFile.getMainClass();
+			System.out.println(clazz);
+			clazz.stream().variableFilter((v) -> Modifier.isPrivate(v.getModifier())); 
+		}catch(Exception ex){
+			ex.printStackTrace();
+		}
+	}
+	
+	
+	/**
+	 * 
+	 * Récupérer la liste des constructeurs
+	 * 		clazz.stream().functionFilter((func) -> func.isConstructor());
+	 * Récupérer la liste des variables privée ainsi que leurs getter/setter
+	 * 		clazz.stream().variableFilter((variable) -> variable.isPrivate()).pair((clazzStreamble, variable) clazzStreamable.functionFilter(func) -> func.getName().endsWith(variable.getName()));
+	 * Récupérer les annotations de n'importe quel type d'element et check si toutes les variables de l'annotation sont override
+	 * 		findAnnotation(true)
+	 * 		pair(
+	 * 			(annotation) -> findAnnotationClass((clazz) -> clazz.getName().equals(annotation.getName()))
+	 * 		)
+	 * 		
+	 * 		return Map<Annotation, AnnotationClass>;
+	 * Récupérer toutes les méthodes qui ne font pas un return de l'un de leurs paramètres
+	 * 		findFunction(func -> !func.isConstructor())
+	 * 			.findReturnOperation((func, operation) -> !func.getVariableNames().contains(operation.getVariableName()))
+	 * 			.parent()
+	 * Vérifier si une variable définie dans la class est utilisée quelque part dans celle-ci.
+	 * 		findVariables((v) -> true)
+	 * 		pair(
+	 * 			(variable) -> findStaticValue((value) -> value.getToken().getValue().equals(variable.getName()))
+	 * 		)
+	 * 
+	 * 		return Map<Variable, Value>;
+	 * Vérifier si une méthode est override par au moins par 2 sous-classes
+	 * 		
+	 * 
+	 */
+
+}