com.weaverplatform.sp4rql.model.restriction.QuadPathRestriction Maven / Gradle / Ivy

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

import com.weaverplatform.sp4rql.error.ParseException;
import com.weaverplatform.sp4rql.model.restriction.path.PathNode;
import com.weaverplatform.sp4rql.model.restriction.path.PathRecord;
import com.weaverplatform.sp4rql.model.token.NullToken;
import com.weaverplatform.sp4rql.model.token.ReferenceToken;
import com.weaverplatform.sp4rql.model.token.Sp4rqlToken;
import com.weaverplatform.sp4rql.model.token.VariableToken;
import com.weaverplatform.util.IndentStringBuilder;

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

public class QuadPathRestriction extends QuadRestriction {

  HashSet pathStart = new HashSet<>();
  HashSet pathEnd = new HashSet<>();

  public QuadPathRestriction(Sp4rqlToken statement, Sp4rqlToken subject, Sp4rqlToken object) {
    super(new NullToken(), subject, null, object);
  }

  public QuadPathRestriction(QuadRestriction unfinishedQuad) {
    super(new NullToken(), unfinishedQuad.getSubject(), null, unfinishedQuad.getObject());
  }

  public void setObject(Sp4rqlToken object) {
    this.object = object;
  }

  public void addPathStart(PathNode node) {
    node.start();
    this.pathStart.add(node);
  }

  public HashSet getPathStart() {
    return pathStart;
  }

  public void addPathEnd(PathNode node) {
    node.end();
    this.pathEnd.add(node);
  }

  public HashSet getPathEnd() {
    return pathEnd;
  }

  public QuadPathRestriction clone() {
    QuadPathRestriction clone = new QuadPathRestriction(statement, subject, object);
    for(PathNode node : pathStart) {
      clone.addPathStart(node);
    }
    for(PathNode node : pathEnd) {
      clone.addPathEnd(node);
    }
    return clone;
  }

  public boolean isSingleTokenPath() {
    if(pathStart.isEmpty()) {
      throw new ParseException("There should be at least one token in the token path");
    }
    if(pathStart.size() > 1 || pathEnd.size() > 1) {
      return false;
    }
    PathNode start = pathStart.iterator().next();
    PathNode end = pathEnd.iterator().next();
    HashSet records = start.getNext();
    if(records.size() > 1) {
      return false;
    }
    PathRecord record = records.iterator().next();
    if(record.keys.size() != 1) {
      return false;
    }
    if(!record.to.equals(end)) {
      return false;
    }
    if(!end.getNext().isEmpty()) {
      return false;
    }
    return true;
  }

  public ReferenceToken getSingleToken() {
    if(!isSingleTokenPath()) {
      throw new ParseException("Do not call getSingleToken when restriction is not a singleTokenPath");
    }
    PathNode start = pathStart.iterator().next();
    HashSet records = start.getNext();
    return records.iterator().next().keys.iterator().next();
  }

  @Override
  public HashSet getExposedVariables() {
    HashSet tokens = new HashSet<>();
    if(subject instanceof VariableToken) {
      tokens.add((VariableToken) subject);
    }
    if(object instanceof VariableToken) {
      tokens.add((VariableToken) object);
    }
    return tokens;
  }

  public void buildString(IndentStringBuilder builder) {
    statement.buildString(builder);
    builder.append(" ");
    subject.buildString(builder);
    builder.append(" (path) ");
    object.buildString(builder);
    builder.appendLine(" .", 1);
    HashSet visited = new HashSet<>();
    Iterator iterator = getPathStart().iterator();
    while(iterator.hasNext()) {
      PathNode node = iterator.next();
      node.toString(builder, visited);
      if(iterator.hasNext()) {
        builder.newline();
      } else {
        builder.updateLevel(-1);
      }
    }
  }
}