@Override public DistinctVariableOnlyDataAtom applyToDistinctVariableOnlyDataAtom(DistinctVariableOnlyDataAtom dataAtom) throws ConversionException { DistinctVariableDataAtom newDataAtom = applyToDistinctVariableDataAtom(dataAtom); if (newDataAtom instanceof DistinctVariableOnlyDataAtom) { return (DistinctVariableOnlyDataAtom) newDataAtom; } else { throw new ConversionException("The substitution has transformed a DistinctVariableOnlyDataAtom into" + "a DistinctVariableDataAtom containing GroundTerm-s: " + newDataAtom); } }
@Override public DistinctVariableOnlyDataAtom applyToDistinctVariableOnlyDataAtom(DistinctVariableOnlyDataAtom dataAtom) throws ConversionException { ImmutableList<? extends ImmutableTerm> newArguments = apply(dataAtom.getArguments()); if (!newArguments.stream().allMatch(t -> t instanceof Variable)) { throw new ConversionException("The substitution applied to a DistinctVariableOnlyDataAtom has " + " produced some non-Variable arguments " + newArguments); } ImmutableList<Variable> variableArguments = (ImmutableList<Variable>) newArguments; if (variableArguments.size() == ImmutableSet.copyOf(variableArguments).size()) return atomFactory.getDistinctVariableOnlyDataAtom(dataAtom.getPredicate(), variableArguments); else { throw new ConversionException("The substitution applied a DistinctVariableOnlyDataAtom has introduced" + " redundant variables: " + newArguments); } }
@Override public DataAtom applyToDataAtom(DataAtom atom) throws ConversionException { ImmutableFunctionalTerm newFunctionalTerm = applyToFunctionalTerm(atom); if (newFunctionalTerm instanceof DataAtom) return (DataAtom) newFunctionalTerm; AtomPredicate predicate = (AtomPredicate) newFunctionalTerm.getFunctionSymbol(); /** * Casts all the sub-terms into VariableOrGroundTerm * * Throws a ConversionException if this cast is impossible. */ ImmutableList.Builder<VariableOrGroundTerm> argBuilder = ImmutableList.builder(); for (ImmutableTerm subTerm : newFunctionalTerm.getArguments()) { if (!(subTerm instanceof VariableOrGroundTerm)) throw new ConversionException("The sub-term: " + subTerm + " is not a VariableOrGroundTerm"); argBuilder.add((VariableOrGroundTerm)subTerm); } return ATOM_FACTORY.getDataAtom(predicate, argBuilder.build()); }
@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); }
@Override public DistinctVariableDataAtom applyToDistinctVariableDataAtom(DistinctVariableDataAtom dataAtom) throws ConversionException { DataAtom newDataAtom = applyToDataAtom(dataAtom); if (newDataAtom instanceof DistinctVariableDataAtom) { return (DistinctVariableDataAtom) newDataAtom; } /** * Checks if new data atom can be converted into a DistinctVariableDataAtom */ if (newDataAtom.getArguments().size() == newDataAtom.getVariables().size()) { return ATOM_FACTORY.getDistinctVariableDataAtom(newDataAtom.getPredicate(), (ImmutableList<Variable>)newDataAtom.getArguments()); } else { throw new ConversionException("The substitution has transformed a DistinctVariableDataAtom into" + "a non-DistinctVariableDataAtom: " + newDataAtom); } }