com.weaverplatform.sp4rql.model.expression.ExpressionUnit Maven / Gradle / Ivy

Go to download
package com.weaverplatform.sp4rql.model.expression;

import com.weaverplatform.sp4rql.error.ParseException;
import com.weaverplatform.sp4rql.model.scope.Sp4rqlScope;
import com.weaverplatform.sp4rql.model.token.VariableToken;
import com.weaverplatform.util.IndentStringBuilder;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class ExpressionUnit implements ExpressionArgument {

  private String operator;
  private ArrayList arguments = new ArrayList<>();
  private boolean distinct = false;
  private boolean wildcard = false; // if the first argument is a wildcard instead of an item in the arguments list

  public ExpressionUnit(String operator) {
    this.operator = operator.toUpperCase();
    if(this.operator.startsWith("HTTP://WWW.W3.ORG/2001/XMLSCHEMA#")) {
      this.operator = String.format("XSD:%s", this.operator.substring(33));
    }
  }

  public void addArgument(ExpressionArgument argument) {
    if(argument == null) {
      throw new ParseException("Do not add null as an argument");
    }
    this.arguments.add(argument);
  }

  public void setDistinct() {
    distinct = true;
  }

  public boolean isDistinct() {
    return distinct;
  }

  public void setWildcard() {
    wildcard = true;
  }

  public boolean isWildcard() {
    return wildcard;
  }

  public void collectExposedVariables(HashSet tokens) {
    for(ExpressionArgument item : arguments) {
      if(item instanceof ExpressionUnit) {
        ((ExpressionUnit) item).collectExposedVariables(tokens);
      } else {
        if(item instanceof VariableToken) {
          tokens.add((VariableToken) item);
        }
      }
    }
  }

  public String getOperator() {
    return operator;
  }

  public ArrayList getArguments() {
    return arguments;
  }

  public boolean isAggregate() {
    if(Operator.isAggregate(getOperator())) {
      return true;
    }
    for(ExpressionArgument argument : arguments) {
      if(argument instanceof ExpressionUnit && ((ExpressionUnit) argument).isAggregate()) {
        return true;
      }
    }
    return false;
  }

  @Override
  public Integer resolvesTo() {
    return OperatorType.getType(operator);
  }

  @Override
  public String toString() {
    return operator;
  }

  public String buildString() {
    IndentStringBuilder builder = new IndentStringBuilder();
    buildString(builder);
    return builder.toString();
  }

  @Override
  public void buildString(IndentStringBuilder builder) {
    builder.append("( ");
    builder.append(operator);
    builder.append(" ");
    if(isDistinct()) {
      builder.append("DISTINCT ");
    }
    if(isWildcard()) {
      builder.append("*");
      if(!arguments.isEmpty()) {
        builder.append(", ");
      }
    }
    Iterator iterator = arguments.iterator();
    while(iterator.hasNext()) {
      ExpressionArgument argument = iterator.next();
      if(argument instanceof Sp4rqlScope) {
        builder.appendLine(String.format("{ # %s", ((Sp4rqlScope)argument).getAlias()), 1);
        argument.buildString(builder);
        builder.newline(-1);
        builder.appendLine("}");
      } else {
        argument.buildString(builder);
      }
      if(iterator.hasNext()) {
        builder.append(", ");
      }
    }
    builder.retract();
    builder.append(" )");
  }
}