Java BuiltinException类代码示例

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
private double averageOfList(Node lst, RuleContext context) {
	java.util.List<Node> l = Util.convertList(lst, context);
	int cnt = 0;
	double sum = 0;
	for (int i = 0; l != null && i < l.size(); i++) {
		Node elt = (Node) l.get(i);
        if (elt != null && elt.isLiteral()) {
        	Object v1 = elt.getLiteralValue();
        	if (v1 instanceof Number) {
        		sum += ((Number) v1).doubleValue();
        		cnt++;
         	}
        	else {
        		throw new BuiltinException(this, context, "Element of list input to max not a number: " + v1.toString());
        	}
        }
        else {
       		throw new BuiltinException(this, context, "Element of list input to max not a Literal: " + elt.toString());
        }
	}
	if (cnt < 1) {
		throw new BuiltinException(this, context, "Can't average an empty List!");
	}
    return sum / cnt;
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * This method is invoked when the builtin is called in a rule head.
 * Such a use is only valid in a forward rule.
 * @param args the array of argument values for the builtin, this is an array 
 * of Nodes.
 * @param length the length of the argument list, may be less than the length of the args array
 * for some rule engines
 * @param context an execution context giving access to other relevant data
 */
@Override
public void headAction(Node[] args, int length, RuleContext context) {
    boolean ok = false;
    InfGraph inf = context.getGraph();
    Graph raw = inf.getRawGraph();
    Graph deductions = inf.getDeductionsGraph();
    for (int i = 0; i < length; i++) {
        Node clauseN = getArg(i, args, context);
        if (Util.isNumeric(clauseN)) {
            int clauseIndex = Util.getIntValue(clauseN);
            Object clause = context.getRule().getBodyElement(clauseIndex);
            if (clause instanceof TriplePattern) {
                Triple t = context.getEnv().instantiate((TriplePattern)clause);
                raw.delete(t);
                deductions.delete(t);
            } else {
                throw new BuiltinException(this, context, "illegal triple to remove non-triple clause");
            }
        } else {
            throw new BuiltinException(this, context, "illegal arg to remove (" + clauseN + "), must be an integer");
        }
    }
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * This method is invoked when the builtin is called in a rule body.
 * @param args the array of argument values for the builtin, this is an array 
 * of Nodes, some of which may be Node_RuleVariables.
 * @param length the length of the argument list, may be less than the length of the args array
 * for some rule engines
 * @param context an execution context giving access to other relevant data
 * @return return true if the buildin predicate is deemed to have succeeded in
 * the current environment
 */
@Override
public boolean bodyCall(Node[] args, int length, RuleContext context) {
    if (length < 2) 
        throw new BuiltinException(this, context, "Must have at least 2 arguments to " + getName());
    String text = getString( getArg(0, args, context), context );
    String pattern = getString( getArg(1, args, context), context );
    Matcher m = Pattern.compile(pattern).matcher(text);
    if ( ! m.matches()) return false;
    if (length > 2) {
        // bind any capture groups
        BindingEnvironment env = context.getEnv();
        for (int i = 0; i < Math.min(length-2, m.groupCount()); i++) {
            String gm = m.group(i+1);
            Node match =  (gm != null) ? Node.createLiteral( gm ) : Node.createLiteral("");
            if ( !env.bind(args[i+2], match) ) return false;
        }
    }
    return true;
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
public boolean bodyCall(Node[] args, int length, RuleContext context)
{
       if (length < 2 || length > 2) 
           throw new BuiltinException(this, context, "Must have 2 arguments to " + getName());
       String str = lex(getArg(0, args, context), context);
       
       return (str.indexOf(lex(getArg(1, args, context), context)) >= 0);
   }
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
protected String lex(Node n, RuleContext context) 
{
    if (n.isBlank()) {
        return n.getBlankNodeLabel();
    } else if (n.isURI()) {
        return n.getURI();
    } else if (n.isLiteral()) {
        return n.getLiteralLexicalForm();
    } else {
        throw new BuiltinException(this, context, "Illegal node type: " + n);
    }
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
public boolean bodyCall(Node[] args, int length, RuleContext context)
{
       if (length < 2 || length > 2) 
           throw new BuiltinException(this, context, "Must have 2 arguments to " + getName());
       String str = lex(getArg(0, args, context), context);
       
       return (str.indexOf(lex(getArg(1, args, context), context)) < 0);
   }
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * This method is invoked when the builtin is called in a rule body.
 * @param args the array of argument values for the builtin, this is an array 
 * of Nodes, some of which may be Node_RuleVariables.
 * @param length the length of the argument list, may be less than the length of the args array
 * for some rule engines
 * @param context an execution context giving access to other relevant data
 * @return return true if the buildin predicate is deemed to have succeeded in
 * the current environment
 */
@Override
public boolean bodyCall(Node[] args, int length, RuleContext context) {
    if (length < 1) 
        throw new BuiltinException(this, context, "Must have at least 1 argument to " + getName());
    StringBuffer buff = new StringBuffer();
    for (int i = 0; i < length-1; i++) {
        buff.append( lex(getArg(i, args, context), context) );
    }
    Node result = Node.createURI( buff.toString() );
    return context.getEnv().bind(args[length-1], result);
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * This method is invoked when the builtin is called in a rule body.
 * @param args the array of argument values for the builtin, this is an array 
 * of Nodes, some of which may be Node_RuleVariables.
 * @param length the length of the argument list, may be less than the length of the args array
 * for some rule engines
 * @param context an execution context giving access to other relevant data
 * @return return true if the buildin predicate is deemed to have succeeded in
 * the current environment
 */
@Override
public boolean bodyCall(Node[] args, int length, RuleContext context) {
    if (length < 1) 
        throw new BuiltinException(this, context, "Must have at least 1 argument to " + getName());
    StringBuffer buff = new StringBuffer();
    for (int i = 0; i < length-1; i++) {
        buff.append( lex(getArg(i, args, context), context) );
    }
    Node result = Node.createLiteral(buff.toString());
    return context.getEnv().bind(args[length-1], result);
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * Return the appropriate lexical form of a node
 */
protected String lex(Node n, RuleContext context) {
    if (n.isBlank()) {
        return n.getBlankNodeLabel();
    } else if (n.isURI()) {
        return n.getURI();
    } else if (n.isLiteral()) {
        return n.getLiteralLexicalForm();
    } else {
        throw new BuiltinException(this, context, "Illegal node type: " + n);
    }
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
 * Return the lexical form of a literal node, error for other node types
 */
protected String getString(Node n, RuleContext context) {
    if (n.isLiteral()) {
        return n.getLiteralLexicalForm();
    } else {
        throw new BuiltinException(this, context, getName() + " takes only literal arguments");
    }
}
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
* This extends the Jena GreaterThan built-in to compare string literals and URIs
*/
  @Override
  public boolean bodyCall(Node[] args, int length, RuleContext context) {
      if (length > 3 || length < 2) {
          throw new BuiltinException(this, context, "builtin " + getName() + " requires 2 or 3 arguments but saw " + length);
      }
      Node n1 = getArg(0, args, context);
      Node n2 = getArg(1, args, context);

      boolean retVal;
      
      if (Util.comparable(n1, n2)) {
      	retVal = super.bodyCall(args, length, context);
  	}
      else {
      	String n1str;
      	String n2str;
      	if (n1.isURI()) {
      		n1str = n1.getURI();
      	}
      	else if (n1.isLiteral()) {
      		n1str = n1.getLiteralValue().toString();
      	}
      	else {
      		n1str = n1.toString();
      	}
      	if (n2.isURI()) {
      		n2str = n2.getURI();
      	}
      	else if (n2.isLiteral()) {
      		n2str = n2.getLiteralValue().toString();
      	}
      	else {
      		n2str = n2.toString();
      	}
      	retVal = (n1str.compareTo(n2str) < 0);
  	}
       
      if (length == 2) {
      	return retVal;
      }
      else {
      	 Node booleanVal =  NodeFactory.createLiteral(LiteralLabelFactory.create(new Boolean(retVal)));
           return context.getEnv().bind(args[length - 1], booleanVal);
      }
  }
 

import com.hp.hpl.jena.reasoner.rulesys.BuiltinException; //导入依赖的package包/类
/**
* This extends the Jena GreaterThan built-in to compare string literals and URIs
*/
  @Override
  public boolean bodyCall(Node[] args, int length, RuleContext context) {
      if (length > 3 || length < 2) {
          throw new BuiltinException(this, context, "builtin " + getName() + " requires 2 or 3 arguments but saw " + length);
      }
      Node n1 = getArg(0, args, context);
      Node n2 = getArg(1, args, context);

      boolean retVal;
      
      if (Util.comparable(n1, n2)) {
      	retVal = super.bodyCall(args, length, context);
   	}
      else {
      	String n1str;
      	String n2str;
      	if (n1.isURI()) {
      		n1str = n1.getURI();
      	}
      	else if (n1.isLiteral()) {
      		n1str = n1.getLiteralValue().toString();
      	}
      	else {
      		n1str = n1.toString();
      	}
      	if (n2.isURI()) {
      		n2str = n2.getURI();
      	}
      	else if (n2.isLiteral()) {
      		n2str = n2.getLiteralValue().toString();
      	}
      	else {
      		n2str = n2.toString();
      	}
      	retVal =  (n1str.compareTo(n2str) > 0);
  	}
      if (length == 2) {
      	return retVal;
      }
      else {
      	 Node booleanVal =  NodeFactory.createLiteral(LiteralLabelFactory.create(new Boolean(retVal)));
           return context.getEnv().bind(args[length - 1], booleanVal);
      }
  }