private void check(ITerm listOne, ITerm expectedResult) throws EvaluationException { builtin = new DistinctValuesBuiltin(listOne); ITuple arguments = BASIC.createTuple(X, Y, Z); ITuple expectedTuple = BASIC.createTuple(expectedResult); ITuple actualTuple = builtin.evaluate(arguments); assertEquals(expectedTuple, actualTuple); }
/** * Represents a string substring operation, but restricts the endIndex to <code>string.length - 1 * </code>. * * @author gigi * @author Adrian Marte */ public class StringSubstringUntilEndBuiltin extends FunctionalBuiltin { private static final IPredicate PREDICATE = BASIC.createPredicate("STRING_SUBSTRING2", 3); /** * Constructor. * * @param terms The terms, where the first term is the string, the second term is the begin index * and the third term represents the result. * @throws IllegalArgumentException if one of the terms is {@code null} */ public StringSubstringUntilEndBuiltin(ITerm... terms) { super(PREDICATE, terms); } protected ITerm computeResult(ITerm[] terms) throws EvaluationException { if (terms[0] instanceof IStringTerm && terms[1] instanceof IIntegerTerm) { IStringTerm string = (IStringTerm) terms[0]; IIntegerTerm beginIndex = (IIntegerTerm) terms[1]; String substring = string.getValue().substring(beginIndex.getValue().intValue()); return Factory.TERM.createString(substring); } return null; } }
/** * Represents the RIF built-in func:contains as described in * http://www.w3.org/TR/xpath-functions/#func-contains. Restricts the value of collation to Unicode * code point collation (http://www.w3.org/2005/xpath-functions/collation/codepoint). */ public class StringContainsWithoutCollationBuiltin extends BooleanBuiltin { private static final IPredicate PREDICATE = BASIC.createPredicate("STRING_CONTAINS2", 2); /** * Constructor. * * @param terms The terms, where the term at the first position is the <code>haystack</code> and * the term at the second position is the <code>needle</code>. The <code>haystack</code> is * the string being searched for the occurrence of the <code>needle</code>. The <code>needle * </code> is the string to be searched for in the <code>haystack</code>. * @throws IllegalArgumentException if one of the terms is {@code null} */ public StringContainsWithoutCollationBuiltin(ITerm... terms) { super(PREDICATE, terms); } @Override protected boolean computeResult(ITerm[] terms) { String haystack = null; String needle = null; if (terms[0] instanceof IStringTerm && terms[1] instanceof StringTerm) { haystack = ((IStringTerm) terms[0]).getValue(); needle = ((IStringTerm) terms[1]).getValue(); } else { return false; } return StringContainsBuiltin.contains(haystack, needle, null); } }
ILiteral createLiteral(boolean positive, String predicateName, Object... termObjects) { List<ITerm> terms = new ArrayList<ITerm>(); for (Object o : termObjects) { if (o instanceof Integer) terms.add(CONCRETE.createInteger((Integer) o)); else if (o instanceof String) terms.add(TERM.createVariable((String) o)); } if (predicateName.equals("=")) return BASIC.createLiteral(positive, new EqualBuiltin(terms.toArray(new ITerm[2]))); return BASIC.createLiteral( positive, BASIC.createAtom( BASIC.createPredicate(predicateName, terms.size()), BASIC.createTuple(terms))); }
/** Represents a string compare operation. */ public class StringCompareBuiltin extends FunctionalBuiltin { /** The predicate defining this built-in. */ private static final IPredicate PREDICATE = BASIC.createPredicate("STRING_COMPARE", 3); /** * Constructor. Three terms must be passed to the constructor, otherwise an exception will be * thrown. * * @param terms The terms. * @throws IllegalArgumentException If one of the terms is {@code null}. * @throws IllegalArgumentException If the number of terms submitted is not 3. * @throws IllegalArgumentException If terms is <code>null</code>. */ public StringCompareBuiltin(ITerm... terms) { super(PREDICATE, terms); } protected ITerm computeResult(ITerm[] terms) throws EvaluationException { if (terms[0] instanceof IStringTerm && terms[1] instanceof IStringTerm) { int result = BuiltinHelper.compare(terms[0], terms[1]); return Factory.CONCRETE.createInteger(result); } return null; } }
private ITuple compute(ITerm term) throws EvaluationException { ToDayTimeDurationBuiltin builtin = new ToDayTimeDurationBuiltin(term, Y); ITuple arguments = BASIC.createTuple(X, Y); ITuple actualTuple = builtin.evaluate(arguments); return actualTuple; }
IRule createRule(ILiteral head, ILiteral... body) { List<ILiteral> h = new ArrayList<ILiteral>(); h.add(head); List<ILiteral> b = new ArrayList<ILiteral>(); for (ILiteral l : body) b.add(l); return BASIC.createRule(h, b); }
/** Represents the RIF built-in predicate pred:date-less-than. */ public class DateLessBuiltin extends LessBuiltin { /** The predicate defining this built-in. */ private static final IPredicate PREDICATE = BASIC.createPredicate("DATE_LESS", 2); public DateLessBuiltin(ITerm... terms) { super(PREDICATE, terms); } @Override protected boolean computeResult(ITerm[] terms) { if (terms[0] instanceof IDateTerm && terms[1] instanceof IDateTerm) { return super.computeResult(terms); } return false; } }
/** * Checks if a term is not of type 'Name'. * * @author Adrian Marte */ public class IsNotNameBuiltin extends BooleanBuiltin { /** The predicate defining this built-in. */ public static final IPredicate PREDICATE = BASIC.createPredicate("IS_NOT_NAME", 1); /** * Constructor. * * @param terms The list of terms. Must always be of length 1 in this case. */ public IsNotNameBuiltin(ITerm... terms) { super(PREDICATE, terms); } protected boolean computeResult(ITerm[] terms) { return !IsNameBuiltin.isName(terms[0]); } }
/** * Checks if a term is of type 'NegativeInteger'. * * @author Adrian Marte */ public class IsNegativeIntegerBuiltin extends BooleanBuiltin { /** The predicate defining this built-in. */ public static final IPredicate PREDICATE = BASIC.createPredicate("IS_NEGATIVEINTEGER", 1); /** * Constructor. * * @param terms The list of terms. Must always be of length 1 in this case. */ public IsNegativeIntegerBuiltin(ITerm... terms) { super(PREDICATE, terms); } protected boolean computeResult(ITerm[] terms) { return isNegativeInteger(terms[0]); } public static boolean isNegativeInteger(ITerm term) { return term instanceof INegativeInteger; } }
/** * Represents a data type conversion function, which converts supported data type instances to * String instances. According to the XPath casting table, all data types are supported to be * converted to String. */ public class ToStringBuiltin extends ConversionBuiltin { private static final IPredicate PREDICATE = BASIC.createPredicate("TO_STRING", 2); /** * Creates a new instance of this builtin. * * @param terms The term representing the data type instance to be converted. */ public ToStringBuiltin(ITerm... terms) { super(PREDICATE, terms); } @Override protected ITerm convert(ITerm term) { if (term instanceof IConcreteTerm) { return toString(term); } return null; } /** * Converts a XMLLiteral term to a String term. The language tag of the XMLLiteral term is * omitted. * * @param term The XMLLiteral term to be converted. * @return A new String term representing the result of the conversion. */ public static IStringTerm toString(IXMLLiteral term) { String string = term.getString(); return TERM.createString(string); } /** * Converts a PlainLiteral term to a String term. The language tag of the PlainLiteral term is * omitted. * * @param term The PlainLiteral term to be converted. * @return A new String term representing the result of the conversion. */ public static IStringTerm toString(IPlainLiteral term) { String string = term.getString(); return TERM.createString(string); } /** * Converts a constant term to a String term. The <code>toCanonicalString</code> method of the * given term is used to convert to String term. * * @param term The term to be converted. * @return A new String term representing the result of the conversion, or <code>null</code> if * the data type represented by the given term is not supported. */ public static IStringTerm toString(ITerm term) { if (term instanceof IConcreteTerm) { if (term instanceof IPlainLiteral) { return toString((IPlainLiteral) term); } else if (term instanceof IStringTerm) { return (IStringTerm) term; } else if (term instanceof IXMLLiteral) { return toString((IXMLLiteral) term); } String string = ((IConcreteTerm) term).toCanonicalString(); return TERM.createString(string); } return null; } }
private void equals(IDayTimeDuration expected, ITerm term) throws EvaluationException { ITuple expectedTuple = BASIC.createTuple(expected); ITuple actualTuple = compute(term); assertEquals(expectedTuple, actualTuple); }