How to use

getArguments

method

in

it.unibz.inf.ontop.model.atom.DataAtom

  protected static boolean hasDuplicates(DataAtom atom) {
    ImmutableList<? extends VariableOrGroundTerm> termList = atom.getArguments();
    Set<VariableOrGroundTerm> termSet = new HashSet<>(termList);

    return termSet.size() < termList.size();
  }
}

protected static boolean hasDuplicates(DataAtom atom) {
  ImmutableList<? extends VariableOrGroundTerm> termList = atom.getArguments();
  Set<VariableOrGroundTerm> termSet = new HashSet<>(termList);
  return termSet.size() < termList.size();
}

private ImmutableList<VariableOrGroundTerm> extractDeterminantArguments(DataAtom dataAtom,
                                    ImmutableList<Integer> determinantIndexes) {
  ImmutableList<? extends VariableOrGroundTerm> arguments = dataAtom.getArguments();
  return determinantIndexes.stream()
      .map(i -> arguments.get(i - 1))
      .collect(ImmutableCollectors.toList());
}

@Override
public ImmutableSet<Variable> getLocalVariables() {
  return atom.getArguments()
      .stream()
      .filter(Variable.class::isInstance)
      .map(Variable.class::cast)
      .collect(ImmutableCollectors.toSet());
}

private ImmutableList<VariableOrGroundTerm> extractDeterminantArguments(DataAtom dataAtom,
                                    ImmutableList<Integer> determinantIndexes) {
  ImmutableList<? extends VariableOrGroundTerm> arguments = dataAtom.getArguments();
  return determinantIndexes.stream()
      .map(i -> arguments.get(i - 1))
      .collect(ImmutableCollectors.toList());
}

private FilterNode createFilter(DataAtom da, ImmutableList<Optional<Variable>> replacementVars) {
  Iterator<Optional<Variable>> it = replacementVars.iterator();
  return iqFactory.createFilterNode(
      getConjunction(da.getArguments().stream()
          .map(a -> getEquality((VariableOrGroundTerm) a, it.next()))
          .filter(e -> ((Optional) e).isPresent())
          .map(e -> ((Optional) e).get())
      ));
}

@Override
protected Optional<IQ> getDefinition(IntensionalDataNode dataNode) {
  DataAtom<AtomPredicate> atom = dataNode.getProjectionAtom();
  return Optional.of(atom)
      .map(DataAtom::getPredicate)
      .filter(p -> p instanceof RDFAtomPredicate)
      .map(p -> (RDFAtomPredicate) p)
      .flatMap(p -> getDefinition(p, atom.getArguments()));
}

  @Override
  public ImmutableSet<Variable> getLocalVariables() {

    return atom.getArguments()
        .stream()
        .filter(Variable.class::isInstance)
        .map(Variable.class::cast)
        .collect(ImmutableCollectors.toSet());

//        ImmutableSet.Builder<Variable> variableBuilder = ImmutableSet.builder();
//        for (VariableOrGroundTerm term : atom.getArguments()) {
//            if (term instanceof Variable)
//                variableBuilder.add((Variable)term);
//        }
//        return variableBuilder.build();
  }

/**
 * TODO: explain
 */
private boolean isRemovable(ExtensionalDataNode node, ImmutableSet<Integer> independentIndexes,
              ImmutableSet<Variable> requiredAndCooccuringVariables) {
  ImmutableList<? extends VariableOrGroundTerm> arguments = node.getProjectionAtom().getArguments();
  return independentIndexes.stream()
      .map(i -> arguments.get(i - 1))
      .allMatch(t -> (t instanceof Variable) && (!requiredAndCooccuringVariables.contains(t)));
}

private Optional<IRI> getPropertyIRI(DataAtom atom) {
  AtomPredicate atomPredicate = atom.getPredicate();
  return Optional.of(atomPredicate)
      .filter(p -> p instanceof RDFAtomPredicate)
      .map(p -> (RDFAtomPredicate) p)
      .flatMap(p -> p.getPropertyIRI(atom.getArguments()));
}

private static boolean extendHomomorphism(Map<Variable, VariableOrGroundTerm> map, DataAtom from, DataAtom to) {
  return from.getPredicate().equals(to.getPredicate())
      && extendHomomorphism(map, from.getArguments(), to.getArguments());
}

/**
 * TODO: explain
 */
private boolean isRemovable(DataNode node, ImmutableSet<Integer> independentIndexes,
              ImmutableSet<Variable> requiredAndCooccuringVariables) {
  ImmutableList<? extends VariableOrGroundTerm> arguments = node.getProjectionAtom().getArguments();
  return independentIndexes.stream()
      .map(i -> arguments.get(i - 1))
      .allMatch(t -> (t instanceof Variable) && (!requiredAndCooccuringVariables.contains(t)));
}

private <P extends AtomPredicate> DataAtom<P> replaceVars(DataAtom<P> projectionAtom, ImmutableList<Optional<Variable>> replacements) {
  Iterator<Optional<Variable>> it = replacements.iterator();
  return atomFactory.getDataAtom(
      projectionAtom.getPredicate(),
      projectionAtom.getArguments().stream()
          .map(a -> {
            Optional<Variable> r = it.next();
            return r.isPresent() ?
                r.get() :
                a;
          })
          .collect(ImmutableCollectors.toList())
  );
}

private DataAtom renameDataAtom(DataAtom atom) {
  ImmutableList.Builder<VariableOrGroundTerm> argListBuilder = ImmutableList.builder();
  for (VariableOrGroundTerm term : atom.getArguments()) {
    argListBuilder.add(renamingSubstitution.applyToTerm(term));
  }
  return ATOM_FACTORY.getDataAtom(atom.getPredicate(), argListBuilder.build());
}

@Override
public boolean isVariableNullable(IntermediateQuery query, Variable variable) {
  if (!getVariables().contains(variable))
    throw new IllegalArgumentException("The variable " + variable + " is not projected by " + this);
  DataAtom<RelationPredicate> atom = getProjectionAtom();
  RelationDefinition relation = atom.getPredicate().getRelationDefinition();
  ImmutableList<? extends VariableOrGroundTerm> arguments = atom.getArguments();
  // NB: DB column indexes start at 1.
  return IntStream.range(1, arguments.size() + 1)
      .filter(i -> arguments.get(i - 1).equals(variable))
      .mapToObj(relation::getAttribute)
      .allMatch(Attribute::canNull);
}

private DataAtom renameDataAtom(DataAtom<? extends AtomPredicate> atom) {
  ImmutableList.Builder<VariableOrGroundTerm> argListBuilder = ImmutableList.builder();
  for (VariableOrGroundTerm term : atom.getArguments()) {
    argListBuilder.add(renamingSubstitution.applyToTerm(term));
  }
  return atomFactory.getDataAtom(atom.getPredicate(), argListBuilder.build());
}

/**
 *
 * TODO: explain
 */
private boolean areMatching(ExtensionalDataNode sourceDataNode, ExtensionalDataNode targetDataNode, ForeignKeyConstraint constraint) {
  ImmutableList<? extends VariableOrGroundTerm> sourceArguments = sourceDataNode.getProjectionAtom().getArguments();
  ImmutableList<? extends VariableOrGroundTerm> targetArguments = targetDataNode.getProjectionAtom().getArguments();
  return constraint.getComponents().stream()
      .allMatch(c -> sourceArguments.get(c.getAttribute().getIndex() - 1)
          .equals(targetArguments.get(c.getReference().getIndex() - 1)));
}

public Function convertToMutableFunction(DataAtom dataAtom) {
  return convertToMutableFunction(dataAtom.getPredicate(), dataAtom.getArguments());
}

/**
 *
 * TODO: explain
 */
private boolean areMatching(DataNode sourceDataNode, DataNode targetDataNode, ForeignKeyConstraint constraint) {
  ImmutableList<? extends VariableOrGroundTerm> sourceArguments = sourceDataNode.getProjectionAtom().getArguments();
  ImmutableList<? extends VariableOrGroundTerm> targetArguments = targetDataNode.getProjectionAtom().getArguments();
  return constraint.getComponents().stream()
      .allMatch(c -> sourceArguments.get(c.getAttribute().getIndex() - 1)
          .equals(targetArguments.get(c.getReference().getIndex() - 1)));
}

@Override
public DataAtom applyToDataAtom(DataAtom atom) throws ConversionException {
  ImmutableList<? extends ImmutableTerm> newArguments = apply(atom.getArguments());
  for (ImmutableTerm subTerm : newArguments) {
    if (!(subTerm instanceof VariableOrGroundTerm))
      throw new ConversionException("The sub-term: " + subTerm + " is not a VariableOrGroundTerm");
  }
  return atomFactory.getDataAtom(atom.getPredicate(),
      (ImmutableList<? extends VariableOrGroundTerm>) newArguments);
}