org.unlaxer.tinyexpression.evaluator.javacode.TinyExpressionTokens Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of tinyExpression Show documentation
TinyExpression implemented with Unlaxer
There is a newer version: 1.4.6
package org.unlaxer.tinyexpression.evaluator.javacode;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.unlaxer.Token;
import org.unlaxer.TypedToken;
import org.unlaxer.tinyexpression.parser.ExpressionInterface;
import org.unlaxer.tinyexpression.parser.ExpressionType;
import org.unlaxer.tinyexpression.parser.ExpressionTypes;
import org.unlaxer.tinyexpression.parser.MethodParser;
import org.unlaxer.tinyexpression.parser.TinyExpressionParser;
import org.unlaxer.tinyexpression.parser.VariableParser;
import org.unlaxer.tinyexpression.parser.javalang.CodeParser.CodeBlock;
import org.unlaxer.tinyexpression.parser.javalang.ImportParser;
import org.unlaxer.tinyexpression.parser.javalang.VariableDeclarationParser;

public class TinyExpressionTokens{
  
  final Token tinyExpressionToken;
  final List codeBlocks;
  final List importTokens;
  final List variableDeclarationTokens;
  final List annotationTokens;
  final TypedToken expressionToken;
  final Map classNameByIdentifier;
  final Map variableDeclarationByVariableName;
  final Map> methodDeclarationBymethodName;
  final List methodTokens;
  final SpecifiedExpressionTypes specifiedExpressionTypes;
  
  public TinyExpressionTokens(Token tinyExpressionToken ,  
      SpecifiedExpressionTypes specifiedExpressionTypes) {
    super();
    this.specifiedExpressionTypes = specifiedExpressionTypes;
    if(false ==tinyExpressionToken.parser instanceof TinyExpressionParser) {
      throw new IllegalArgumentException();
    }
    this.tinyExpressionToken = tinyExpressionToken;
    codeBlocks = TinyExpressionParser.extractCodeBlocksAsModel(tinyExpressionToken);
    importTokens = TinyExpressionParser.extractImports(tinyExpressionToken);
    expressionToken = TinyExpressionParser.extractExpressionWithAfterReduced(tinyExpressionToken);
    
    variableDeclarationTokens = TinyExpressionParser.extractVariables(tinyExpressionToken);
    annotationTokens = TinyExpressionParser.extractAnnotaions(tinyExpressionToken);
    
    classNameByIdentifier = importTokens.stream()
      .collect(
        Collectors.toMap(
          importToken->(String)(ImportParser.extractIdentifier(importToken).getToken().orElse("")),
          importToken->(String)(ImportParser.extractJavaClassMethodOrClassName(importToken).getToken().orElse(""))
        )
      );
    
    variableDeclarationByVariableName = variableDeclarationTokens.stream()
      .collect(Collectors.toMap(
        token->{
            TypedToken extractVariableParserToOken = VariableDeclarationParser.extractVariableParserToken(token);
            VariableParser parser = extractVariableParserToOken.getParser(VariableParser.class);
            String variableName = parser.getVariableName(extractVariableParserToOken);
            return variableName;
        
        },
        Function.identity())
      );
    
    methodTokens = TinyExpressionParser.extractMethods(tinyExpressionToken);
    
    methodDeclarationBymethodName = methodTokens.stream()
       .map(_token->_token.typedWithInterface(MethodParser.class))
       .collect(Collectors.toMap(
           _token->{
             MethodParser parser = _token.getParser(MethodParser.class);
             
             return (parser.methodName(_token).getToken().get());
           },
           Function.identity()
           )
       );
  }
  
  public ExpressionType numberType() {
    if(specifiedExpressionTypes.numberType() != null) {
      return specifiedExpressionTypes.numberType();
    }
    if(specifiedExpressionTypes.resultType()!= null && specifiedExpressionTypes.resultType().isNumber()) {
      return specifiedExpressionTypes.resultType();
    }
    return ExpressionTypes._float;
  }
  
  public Token getTinyExpressionToken() {
    return tinyExpressionToken;
  }
  public List getImportTokens() {
    return importTokens;
  }
  public List getVariableDeclarationTokens() {
    return variableDeclarationTokens;
  }
  public List getAnnotationsToken() {
    return annotationTokens;
  }
  public Token getExpressionToken() {
    return expressionToken;
  }
  public List getMethodTokens() {
    return methodTokens;
  }

  public String resolveJavaClass(String classNameOrMethod) {
    String string = classNameByIdentifier.get(classNameOrMethod);
    return string == null ? classNameOrMethod : string;
  }
  
  public java.util.Optional matchedVariableDeclaration(String VariableName){
    
    Token token = variableDeclarationByVariableName.get(VariableName);
    return java.util.Optional.ofNullable(token);
  }
  
  public java.util.Optional matchedTypeFromVariableDeclaration(String VariableName){
	    
	    Token token = variableDeclarationByVariableName.get(VariableName);
	    return java.util.Optional.ofNullable(token);
  }
  
//  public java.util.Optional matchedMethod(String VariableName){
//
//     
//    Token token = variableDeclarationByVariableName.get(VariableName);
//    return java.util.Optional.ofNullable(token);
//  }
  
  public Optional getMethodToken(String methodName){
    Token token = methodDeclarationBymethodName.get(methodName);
    return Optional.ofNullable(token);
  }

  public List getAnnotationTokens() {
    return annotationTokens;
  }

  public Map getClassNameByIdentifier() {
    return classNameByIdentifier;
  }

  public Map getVariableDeclarationByVariableName() {
    return variableDeclarationByVariableName;
  }

  public Map> getMethodDeclarationBymethodName() {
    return methodDeclarationBymethodName;
  }
  
  
}