org.unlaxer.tinyexpression.parser.javalang.VariableDeclarationParser 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.parser.javalang;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.unlaxer.Name;
import org.unlaxer.Token;
import org.unlaxer.TokenPredicators;
import org.unlaxer.TypedToken;
import org.unlaxer.context.ParseContext;
import org.unlaxer.listener.OutputLevel;
import org.unlaxer.listener.TransactionListener;
import org.unlaxer.parser.Parser;
import org.unlaxer.parser.Parsers;
import org.unlaxer.parser.combinator.Choice;
import org.unlaxer.parser.combinator.ChoiceInterface;
import org.unlaxer.parser.combinator.LazyChoice;
import org.unlaxer.tinyexpression.parser.BooleanVariableParser;
import org.unlaxer.tinyexpression.parser.ExpressionTypes;
import org.unlaxer.tinyexpression.parser.NumberVariableParser;
import org.unlaxer.tinyexpression.parser.StringVariableParser;
import org.unlaxer.tinyexpression.parser.TypeHint;
import org.unlaxer.tinyexpression.parser.VariableParser;
import org.unlaxer.util.annotation.TokenExtractor;

@SuppressWarnings("serial")
public class VariableDeclarationParser extends LazyChoice implements TransactionListener{

  @Override
  public org.unlaxer.parser.Parsers getLazyParsers() {
    return new Parsers(
        Parser.get(NumberVariableDeclarationParser.class),
        Parser.get(StringVariableDeclarationParser.class),
        Parser.get(BooleanVariableDeclarationParser.class)
    );
  }
  
  public VariableDeclarationParser() {
    super();
    variableDeclarations = new VariableDeclarations();
  }
  
  VariableDeclarations variableDeclarations;
  
  @TokenExtractor
  public static TypedToken extractVariableParserToken(Token thisParserParsed) {
    
    Token choiced = thisParserParsed;
    Parser parser = thisParserParsed.getParser();
    if(parser instanceof Choice) {
      
      choiced = ChoiceInterface.choiced(thisParserParsed);
    }
    
    parser = choiced.getParser();
      
    if(parser instanceof AbstractVariableDeclarationParser) {
      
      return choiced.getChild(TokenPredicators.parserImplements(VariableParser.class))
          .typed(VariableParser.class);
    }
    throw new IllegalArgumentException();
  }
  
  @TokenExtractor
  public static VariableInfo extractVariableInfo(Token thisParserParsed) {
    
    TypedToken variableParserToken = extractVariableParserToken(thisParserParsed);
    VariableParser parser = variableParserToken.getParser();
    TypedToken typed = thisParserParsed.flatten().stream()
        .filter(TokenPredicators.parserImplements(TypeHint.class))//
        .findFirst().get()
        .typed(TypeHint.class);
        
    ExpressionTypes expressionType = typed.getParser().type();
    String variableName = parser.getVariableName(variableParserToken);
    return new VariableInfo(expressionType, variableName);
  }
  
  
  
  public static class VariableInfo{
    
    public final ExpressionTypes expressionType;
    public String name;
    public VariableInfo(ExpressionTypes expressionType, String name) {
      super();
      this.expressionType = expressionType;
      this.name = name;
    }
    
    public VariableParser matchedVariableParser() {
      
      switch (expressionType) {
        case _boolean:
          return Parser.get(BooleanVariableParser.class);
        case number:
          return Parser.get(NumberVariableParser.class);
        case string:
          return Parser.get(StringVariableParser.class);
        case object:
        default:
          throw new IllegalArgumentException();
      }
      
    }
  }

  @Override
  public void setLevel(OutputLevel level) {
  }

  @Override
  public void onOpen(ParseContext parseContext) {
  }

  @Override
  public void onBegin(ParseContext parseContext, Parser parser) {
  }

  @Override
  public void onCommit(ParseContext parseContext, Parser parser, List committedTokens) {
    
    if(false == parser instanceof AbstractVariableDeclarationParser) {
      return ;
    }
    
    //Number or String or boolean VariableDeclararionParser
    Token token = committedTokens.get(0);
    
    VariableInfo variableInfo = extractVariableInfo(token);
    variableDeclarations.set(parseContext, variableInfo);
  }

  @Override
  public void onRollback(ParseContext parseContext, Parser parser, List rollbackedTokens) {
    
//    if(false == parser instanceof AbstractVariableDeclarationParser) {
//      return ;
//    }
//    
//    Token token = rollbackedTokens.get(0);
//    
//    VariableInfo variableInfo = extractVariableInfo(token);
//    variableDeclarations.remove(parseContext, variableInfo.name);
    
  }

  @Override
  public void onClose(ParseContext parseContext) {
  }
  
  public static class VariableDeclarations{
    
    public static final VariableDeclarations SINGLETON = new VariableDeclarations();
    
    public static final Name STORES = Name.of(VariableDeclarations.class , "Stores");
    
    @SuppressWarnings("unchecked")
    Map infoByName(ParseContext parseContext){
      Map globalScopeTreeMap = parseContext.getGlobalScopeTreeMap();
      Map infoByName = (Map) globalScopeTreeMap
          .computeIfAbsent(STORES,name->new HashMap<>());
      return infoByName;
      
    }
    
    public void set(ParseContext parseContext , VariableInfo variableInfo) {
      
      infoByName(parseContext).put(variableInfo.name, variableInfo); 
    }
    
    /**
     * @param parseContext
     * @param variableName
     * @return VariableInfo removed
     */
    public VariableInfo remove(ParseContext parseContext , String variableName) {
      
      
      return infoByName(parseContext).remove(variableName);
    }
    
    public Optional get(ParseContext parseContext , String variableName) {
      
      return Optional.ofNullable(infoByName(parseContext).get(variableName));
    }
  }
  
}