peer-at-code-parser-java/src/dev/peerat/parser/java/Value.java

package dev.peerat.parser.java;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

import dev.peerat.parser.Token;
import dev.peerat.parser.java.Operation.OperationContainer;
import dev.peerat.parser.java.Variable.VariableContainer;

public class Value extends JavaElement{
	
	private Token token;
	private JavaElement content;
	
	Value(){}
	
	public Value(Token token){
		this.token = token;
	}
	
	public Value(JavaElement content){
		this.content = content;
	}
	
	public Token getToken(){
		return this.token;
	}
	
	public JavaElement getContent(){
		return this.content;
	}
	
	@Override
	public String toString(){
		return "Value[token="+token+", content="+content+"]";
	}
	
	@Override
	public void build(Builder builder) throws Exception{
		if(token != null){
			builder.append(token);
		}else{
			content.build(builder);
		}
	}
	
	@Override
	public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){
		return content != null ? finder.apply(content)  ? (E) content : null : null;
	}
	
	@Override
	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
		if(content != null){
			if(finder.apply(content)) list.add((E) content);
			content.findAll(finder, list);
		}
	}
	
	public static class BiValue extends Value{
		
		private Value left;
		private String action;
		private Value right;
		
		public BiValue(Value left, String action, Value right){
			this.left = left;
			this.action = action;
			this.right = right;
		}
		
		public Value left(){
			return left;
		}
		
		public String getAction(){
			return this.action;
		}
		
		public Value right(){
			return right;
		}
		
		@Override
		public String toString(){
			return left+" "+action+" "+right;
		}
		
		@Override
		public void build(Builder builder) throws Exception{
			left.build(builder);
			builder.append(action);
			right.build(builder);
		}
		
		@Override
		public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){
			return finder.apply(left) ? (E) left : finder.apply(right) ? (E) right : null;
		}
		
		@Override
		public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){
			if(finder.apply(left)) list.add((E)left);
			left.findAll(finder, list);
			if(finder.apply(right)) list.add((E)right);
			right.findAll(finder, list);
		}
	}
	
	public static class TriValue extends Value{
		
		private Value check;
		private Value success;
		private Value fail;
		
		public TriValue(){}
		
		public Value getChecker(){
			return check;
		}
		
		public Value success(){
			return success;
		}
		
		public Value fail(){
			return fail;
		}
		
		@Override
		public void build(Builder builder) throws Exception {
			check.build(builder);
			builder.append("?");
			success.build(builder);
			builder.append(":");
			fail.build(builder);
		}
		
		@Override
		public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){
			return finder.apply(check) ? (E) check : finder.apply(success) ? (E) success : finder.apply(fail) ? (E) fail : null;
		}
		
		@Override
		public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){
			if(finder.apply(check)) list.add((E)check);
			check.findAll(finder, list);
			if(finder.apply(success)) list.add((E)success);
			success.findAll(finder, list);
			if(finder.apply(fail)) list.add((E)fail);
			fail.findAll(finder, list);
		}
	}

	public static class MethodCallValue extends Value{
		
		private Value base;
		private Token generic;
		private Token token;
		private List<Value> parameters;
		
		public MethodCallValue(Value base, Token generic, Token token, List<Value> parameters){
			this.base = base;
			this.generic = generic;
			this.token = token;
			this.parameters = parameters;
		}
		
		public Value base(){
			return this.base;
		}
		
		public Token getGeneric(){
			return this.generic;
		}
		
		public Token getToken(){
			return token;
		}
		
		public List<Value> getParameters(){
			return this.parameters;
		}
		
		@Override
		public String toString(){
			return base+"."+((generic == null ? "":generic.getValue()))+token.getValue()+((parameters == null ? "":parameters));
		}
		
		@Override
		public void build(Builder builder) throws Exception{
			builder.append(token);
		}
		
		@Override
		public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){
			if(finder.apply(base)) return (E) base;
			if(parameters != null){
				for(Value value : parameters){
					if(finder.apply(value)) return (E) value;
				}
			}
			return null;
		}
		
		@Override
		public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){
			if(finder.apply(base)) list.add((E) base);
			base.findAll(finder, list);
			if(parameters != null){
				for(Value value : parameters){
					if(finder.apply(value)) list.add((E) value);
					value.findAll(finder, list);
				}
			}
		}
	}
	
	public static class InstanceValue extends Value{
		
		private Token newer;
		private Token token;
		private List<Value> parameters;
		
		public InstanceValue(Token newer, Token token, List<Value> parameters){
			this.newer = newer;
			this.token = token;
			this.parameters = parameters;
		}
		
		public Token getNewer(){
			return this.newer;
		}
		
		public Token getToken(){
			return token;
		}
		
		public List<Value> getParameters(){
			return this.parameters;
		}
		
		@Override
		public String toString(){
			return newer.getValue()+" "+token.getValue()+((parameters == null ? "":parameters));
		}
		
		@Override
		public void build(Builder builder) throws Exception{
			builder.append(newer);
			builder.append(token);
		}
		
		@Override
		public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder){
			if(parameters != null){
				for(Value value : parameters){
					if(finder.apply(value)) return (E) value;
				}
			}
			return null;
		}
		
		@Override
		public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){
			if(parameters != null){
				for(Value value : parameters){
					if(finder.apply(value)) list.add((E) value);
					value.findAll(finder, list);
				}
			}
		}
	}
	
	//TO FILL
	public static class LambdaValue extends Value implements OperationContainer, VariableContainer{
		
		private List<Token> parameters;
		private List<JavaElement> operations;
		
		public LambdaValue(List<Token> parameters, List<JavaElement> operations){
			this.parameters = parameters;
			this.operations = operations;
		}
		
		public LambdaValue(List<Token> parameters, Value value){
			this.parameters = parameters;
			this.operations = new ArrayList<>();
			this.operations.add(value);
		}
		
		public List<Token> getParameters(){
			return this.parameters;
		}
		
		public List<JavaElement> getOperations(){
			return this.operations;
		}
		
		@Override
		public void addVariable(Variable variable){
			this.operations.add(variable);
		}

		@Override
		public void addOperation(Operation operation) {
			this.operations.add(operation);
		}
		
		
		@Override
		public String toString(){
			return "("+parameters+") -> {"+operations+"}";
		}
		
		@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){
		}

	}
}