How to use

getPredicate

method

in

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

@Override
protected Optional<IQ> getDefinition(IntensionalDataNode dataNode) {
  return Optional.ofNullable(map.get(dataNode.getProjectionAtom().getPredicate()));
}

protected static ImmutableMultimap<RelationPredicate, ExtensionalDataNode> extractDataNodes(ImmutableList<QueryNode> siblings) {
  ImmutableMultimap.Builder<RelationPredicate, ExtensionalDataNode> mapBuilder = ImmutableMultimap.builder();
  for (QueryNode node : siblings) {
    if (node instanceof ExtensionalDataNode) {
      ExtensionalDataNode dataNode = (ExtensionalDataNode) node;
      mapBuilder.put(dataNode.getProjectionAtom().getPredicate(), dataNode);
    }
  }
  return mapBuilder.build();
}

private RDFAtomPredicate getRDFAtomPredicate(DataAtom atom){
  return Optional.of(atom.getPredicate())
      .filter(p -> p instanceof RDFAtomPredicate)
      .map(p -> (RDFAtomPredicate) p)
      .orElseThrow(() -> new CanonicalTransformerException(RDFAtomPredicate.class.getName() + " expected"));
}

protected static ImmutableMultimap<AtomPredicate, DataNode> extractDataNodes(ImmutableList<QueryNode> siblings) {
  ImmutableMultimap.Builder<AtomPredicate, DataNode> mapBuilder = ImmutableMultimap.builder();
  for (QueryNode node : siblings) {
    if (node instanceof DataNode) {
      DataNode dataNode = (DataNode) node;
      mapBuilder.put(dataNode.getProjectionAtom().getPredicate(), dataNode);
    }
  }
  return mapBuilder.build();
}

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());
}

@Override
public boolean hasSamePredicateAndArity(DataAtom otherAtom) {
  if (!predicate.equals(otherAtom.getPredicate()))
    return false;
  if (getEffectiveArity() != otherAtom.getEffectiveArity())
    return false;
  return true;
}

/**
 * Predicates not having a DatabaseRelationDefinition are ignored
 */
private ImmutableMultimap<RelationDefinition, ExtensionalDataNode> extractDataNodeMap(IntermediateQuery query,
                                           InnerJoinNode joinNode) {
  return query.getChildren(joinNode).stream()
      .filter(c -> c instanceof ExtensionalDataNode)
      .map(c -> (ExtensionalDataNode) c)
      .map(c -> Maps.immutableEntry(c.getProjectionAtom().getPredicate().getRelationDefinition(), c))
      .collect(ImmutableCollectors.toMultimap());
}

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);
}

/**
 * TODO: explain
 */
public DataNode createDataNode(IntermediateQueryFactory iqFactory, DataAtom dataAtom,
                   Collection<Predicate> tablePredicates) {
  if (tablePredicates.contains(dataAtom.getPredicate())) {
    return iqFactory.createExtensionalDataNode(dataAtom);
  }
  return iqFactory.createIntensionalDataNode(dataAtom);
}

/**
 * TODO: explain
 */
public static DataNode createDataNode(IntermediateQueryFactory iqFactory, DataAtom dataAtom,
                   Collection<Predicate> tablePredicates) {
  if (tablePredicates.contains(dataAtom.getPredicate())) {
    return iqFactory.createExtensionalDataNode(dataAtom);
  }
  return iqFactory.createIntensionalDataNode(dataAtom);
}

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());
}

@Override
protected Optional<IQ> getDefinition(IntensionalDataNode dataNode) {
  if (getPropertyIRI(dataNode.getProjectionAtom())
      .filter(i -> i.equals(Ontop.CANONICAL_IRI))
      .isPresent()) {
    return Optional.of(definition);
  }
  throw new UnexpectedPredicateException(dataNode.getProjectionAtom().getPredicate());
}

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

protected DataNode generateDataNode(DataNode formerDataNode, ImmutableList<VariableOrGroundTerm> arguments) {
  DataAtom dataAtom = ATOM_FACTORY.getDataAtom(formerDataNode.getProjectionAtom().getPredicate(), arguments);
  if (formerDataNode instanceof ExtensionalDataNode) {
    return iqFactory.createExtensionalDataNode(dataAtom);
  }
  else if (formerDataNode instanceof IntensionalDataNode) {
    return iqFactory.createIntensionalDataNode(dataAtom);
  }
  else {
    throw new RuntimeException("Transformation of a data node of type "
        + formerDataNode.getClass() + " is not supported yet");
  }
}

private static ImmutableSubstitution<VariableOrGroundTerm> extractSubstitution(DistinctVariableOnlyDataAtom sourceAtom,
                                        DataAtom targetAtom) {
  if (!sourceAtom.getPredicate().equals(targetAtom.getPredicate())) {
    throw new IllegalStateException("Incompatible predicates");
  }
  else if (sourceAtom.getEffectiveArity() != targetAtom.getEffectiveArity()) {
    throw new IllegalStateException("Different arities");
  }
  ImmutableMap<Variable, VariableOrGroundTerm> newMap = FunctionalTools.zip(
      sourceAtom.getArguments(),
      (ImmutableList<VariableOrGroundTerm>) targetAtom.getArguments()).stream()
      .collect(ImmutableCollectors.toMap());
  return SUBSTITUTION_FACTORY.getSubstitution(newMap);
}

  private ImmutableSubstitution<VariableOrGroundTerm> extractSubstitution(DistinctVariableOnlyDataAtom sourceAtom,
                                      DataAtom targetAtom) {
    if (!sourceAtom.getPredicate().equals(targetAtom.getPredicate())) {
      throw new IllegalStateException("Incompatible predicates");
    }
    else if (sourceAtom.getEffectiveArity() != targetAtom.getEffectiveArity()) {
      throw new IllegalStateException("Different arities");
    }
    ImmutableMap<Variable, VariableOrGroundTerm> newMap = FunctionalTools.zip(
        sourceAtom.getArguments(),
        (ImmutableList<VariableOrGroundTerm>) targetAtom.getArguments()).stream()
        .collect(ImmutableCollectors.toMap());
    return substitutionFactory.getSubstitution(newMap);
  }
}

@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);
}