Java Var.alloc方法代码示例

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    TestingSelector testingSelector = (TestingSelector) nodeSelector;
    FunctionTest functionTest = (FunctionTest) testingSelector.getTest();

    if(functionTest.getArgSelectors().get(0) instanceof PropertySelector) {
        PropertySelector arg = (PropertySelector) functionTest.getArgSelectors().get(0);
        PropertySelector delegate = (PropertySelector) testingSelector.getDelegate();

        Var target = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(delegate.getProperty().toString()), target));

        Var selector = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(target.asNode(), NodeFactory.createURI(arg.getProperty().toString()), selector.asNode()));

        elementGroup.addElementFilter(new ElementFilter(new E_IsLiteral(new ExprVar(selector))));

        return selector;
    } else {
        throw new IllegalStateException("Argument of function isLiteral has to be a PropertySelector");
    }
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
protected static ViewDefinition buildViewDefFromInfo(ViewDefinitionInfo viewDefInfo) {
    Multimap<Var, RestrictedExpr> varToExprs = HashMultimap.create();

    for (Node node : viewDefInfo.termConstructors.keySet()) {
        Var var = Var.alloc(((Node_Variable) node).getName());
        RestrictedExpr restr = new RestrictedExpr(viewDefInfo.termConstructors.get(node));
        varToExprs.put(var, restr);
    }

    VarDefinition varDef = new VarDefinition(varToExprs);

    QuadPattern quadPattern = buildQuadPattern(viewDefInfo.quadPatternInfo);
    Mapping mapping = new Mapping(varDef, viewDefInfo.from);

    return new ViewDefinition(viewDefInfo.name, quadPattern, null, mapping, null);
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
private Node termToNode(QueryVars queryVars, Term term) {
	if (term instanceof FunctionalTerm) {
		try {
			URI uri = new URI(term.getName());
			return NodeFactory.createURI(uri.toString());
		} catch (MalformedURIException e) {
			return NodeFactory.createLiteral(term.toString());
		}
	} else if (term instanceof Variable) {
		QueryVar queryVar = queryVars.get(term.getMinVariableIndex());
		if (queryVar!=null){
			return Var.alloc(queryVar.getLinkedName(this));
		}else{
			return Var.alloc(Integer.toString(term.getMinVariableIndex()));
		}
		} else {
		return null;
	}
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
public Domain map1(Binding binding) {
	Domain d = new Domain(variables.length);
	for (int i = 0; i < variables.length; i++) {
		Var v = Var.alloc(variables[i]);
		Node value = binding.get(v);
		int index = ((Integer) indexes.get(v)).intValue();
		d.setElement(index, value);
	}
	return d;
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
private String getString(String[] vars, List<Binding> bindings) {
  StringBuilder message = new StringBuilder();
  for (Binding binding : bindings) {
    for (String varName : vars) {
      final Var var = Var.alloc(varName);
      message.append(asURI(binding.get(var).toString(false))).append("\t");
    }
    message.append('\n');
  }
  return message.toString();
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Expr evaluate(NodeTest nodeTest, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    IsATest isATest = (IsATest) nodeTest;
    Var tmpVar = Var.alloc(Var.alloc(VarIDGenerator.createID()));
    elementGroup.addTriplePattern(new Triple(var.asNode(), RDF.type.asNode(), tmpVar.asNode()));
    return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", ""))));
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    PropertySelector propertySelector = (PropertySelector) nodeSelector;
    if (propertySelector instanceof WildcardSelector) {
        throw new IllegalStateException(propertySelector.getClass() + " is not supported.");
    }

    Var id = Var.alloc(VarIDGenerator.createID());
    elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(propertySelector.getProperty().toString()), id.asNode()));

    return id;
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    ReversePropertySelector reversePropertySelector = (ReversePropertySelector) nodeSelector;
    Var id = Var.alloc(VarIDGenerator.createID());
    ElementPathBlock epb = new ElementPathBlock();
    epb.addTriple(new TriplePath(var.asNode(), new P_Inverse(new P_Link(NodeFactory.createURI(reversePropertySelector.getProperty().toString()))), id.asNode()));
    ElementGroup group = new ElementGroup();
    group.addElement(epb);
    elementGroup.addElement(group);
    return id;
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    UnionSelector unionSelector = (UnionSelector) nodeSelector;

    NodeSelector nodeSelectorLeft = unionSelector.getLeft();
    NodeSelector nodeSelectorRight = unionSelector.getRight();

    ElementGroup leftGroup = new ElementGroup();
    ElementGroup rightGroup = new ElementGroup();

    Var leftVar = LDPathEvaluator.evaluate(nodeSelectorLeft, leftGroup, var, evaluatorConfiguration);
    Var rightVar = LDPathEvaluator.evaluate(nodeSelectorRight, rightGroup, var, evaluatorConfiguration);

    Var subVar = Var.alloc(VarIDGenerator.createID());

    Query leftSubQuery = new Query();
    leftGroup.addElement(new ElementBind(subVar, new NodeValueNode(leftVar.asNode())));
    leftSubQuery.setQueryPattern(leftGroup);
    leftSubQuery.addResultVar(var);
    leftSubQuery.addResultVar(subVar);
    leftSubQuery.setQuerySelectType();
    ElementSubQuery leftESubQuery = new ElementSubQuery(leftSubQuery);

    Query rightSubQuery = new Query();
    rightGroup.addElement(new ElementBind(subVar, new NodeValueNode(rightVar.asNode())));
    rightSubQuery.setQueryPattern(rightGroup);
    rightSubQuery.addResultVar(var);
    rightSubQuery.addResultVar(subVar);
    rightSubQuery.setQuerySelectType();
    ElementSubQuery rightESubQuery = new ElementSubQuery(rightSubQuery);


    ElementUnion elementUnion = new ElementUnion();

    elementUnion.addElement(leftESubQuery);
    elementUnion.addElement(rightESubQuery);
    elementGroup.addElement(elementUnion);

    return subVar;
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
public static <T extends ResourceObject> Query evaluate(QueryServiceConfiguration queryServiceDTO, URI rootType) throws ParseException {

        Query query = QueryFactory.make();
        query.setQuerySelectType();

        ElementGroup elementGroup = new ElementGroup();

        Var objectVar = Var.alloc("root");

        // Creating and adding the first triple - could be something like: "?objectVar rdf:type oa:Annotation
        Triple t1 = new Triple(objectVar, RDF.type.asNode(), NodeFactory.createURI(rootType.toString()));
        elementGroup.addTriplePattern(t1);

        // Evaluating the criteria
        for (Criteria c : queryServiceDTO.getCriteria()) {
            SesameValueBackend backend = new SesameValueBackend();

            LdPathParser parser = new LdPathParser(backend, queryServiceDTO.getConfiguration(), new StringReader(c.getLdpath()));
            Var var = LDPathEvaluator.evaluate(parser.parseSelector(queryServiceDTO.getPrefixes()), elementGroup, objectVar, queryServiceDTO.getEvaluatorConfiguration());

            if (c.getConstraint() != null) {
                String resolvedConstraint = resolveConstraintPrefix(c.getConstraint(), queryServiceDTO, parser);
                EvalComparison.evaluate(elementGroup, c, var, resolvedConstraint);
            }
        }

        // Adding all generated patterns to the query object
        query.setQueryPattern(elementGroup);

        // Choose what we want so select - SELECT ?annotation in this case
        query.addResultVar(objectVar);

        // Setting the default prefixes, like rdf: or dc:
        query.getPrefixMapping().setNsPrefixes(queryServiceDTO.getPrefixes());

        return query;
    }
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
public Set<ViewQuad<ViewDefinition>> getViewCandidates(Triple triple) {
	Var g = Var.alloc("g");
	Var s = Var.alloc("s");
	Var p = Var.alloc("p");
	Var o = Var.alloc("o");

	Node gv = Quad.defaultGraphNodeGenerated;
	Node sv = triple.getSubject();
	Node pv = triple.getPredicate();
	Node ov = triple.getObject();
	
	Quad tmpQuad = new Quad(g, s, p, o);
	
	RestrictionManagerImpl r = new RestrictionManagerImpl();
	
	Set<Clause> clauses = new HashSet<Clause>();
	clauses.add(new Clause(new E_Equals(new ExprVar(g), NodeValue.makeNode(gv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(s), NodeValue.makeNode(sv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(p), NodeValue.makeNode(pv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(o), NodeValue.makeNode(ov))));

	NestedNormalForm nnf = new NestedNormalForm(clauses);
	
	r.stateCnf(nnf);
	
	Set<ViewQuad<ViewDefinition>> result = candidateSelector.findCandidates(tmpQuad, r);
	
	return result;
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
private Node termToNode(Dataset dataset, Term term) {
	if (term instanceof FunctionalTerm) {
		try {
			URI uri = new URI(term.getName());
			return NodeFactory.createURI(uri.toString());
		} catch (MalformedURIException e) {
			return NodeFactory.createLiteral(term.toString());
		}
	} else if (term instanceof Variable) {
		QueryVar queryVar = globalQueryVars.get(term.getMinVariableIndex());
		return Var.alloc(queryVar.getLinkedName(dataset));
		} else {
		return null;
	}
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public Op transform(OpFilter opFilter, Op subOp) {

	ExprList substitutedExprList = new ExprList();
	
	for (Expr expr: opFilter.getExprs().getList()){
		Map<String, Expr> substitutions = new HashMap<String, Expr>();
		//for each expression see if it contains variables that are not mentioned within this clause
		for (Var var: expr.getVarsMentioned()){
			QueryVar mentionedQueryVar=this.mentionedVars.get(var);
			if (mentionedQueryVar==null) {
				//No mentioned variables so filter not relevant
				return subOp;
			}else
			{
				//Mentioned so add the new name to the substitutions set.
				Var substitutedVar = Var.alloc(mentionedQueryVar.getLinkedName(this.queryClause.getDataset()));
				substitutions.put(var.getName(), new ExprVar(substitutedVar));
			}
		}
		//Only get here if all vars mentioned in expression are within clause
	
		ExprTransformSubstitute exprTransformSubstitute = new ExprTransformSubstitute(	substitutions );
		Expr substitutedExpression = (Expr) ExprTransformer.transform(exprTransformSubstitute, expr);
		substitutedExprList.add(substitutedExpression);
	}
	return OpFilter.filter(substitutedExprList, subOp);
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
public void prepare(Map stormConf, TopologyContext context,	OutputCollector collector) {
	this.collector = collector;
	this.triplesPattern = new ArrayList<Triple>();
	for (String str : this.stringPattern) {
		String[] triple = str.split(" ");
		Node s = null;
		Node p = null;
		Node o = null;
		// Subject definition
		if (triple[0].startsWith("?")) {
			s = Var.alloc(triple[0].substring(1));
		}
		else {
			s = ResourceFactory.createResource(triple[0]).asNode();
		}
		// Property definition
		if (triple[1].startsWith("?")) {
			p = Var.alloc(triple[1].substring(1));
		}
		else {
			p = ResourceFactory.createProperty(triple[1]).asNode();
		}
		// Object definition
		if (triple[2].startsWith("?")) {
			o = Var.alloc(triple[2].substring(1));
		}
		else {
			o = ResourceFactory.createResource(triple[2]).asNode();
		}
		triplesPattern.add(Triple.create(s, p, o));
	}
	this.pattern = BasicPattern.wrap(triplesPattern);
	this.opBGP = new OpBGP(pattern);
}
 

import com.hp.hpl.jena.sparql.core.Var; //导入方法依赖的package包/类
@Override
	/*
	 * (non-Javadoc)
	 * @see backtype.storm.task.IBolt#execute(backtype.storm.tuple.Tuple)
	 * We assume that each tuple here is a set of graphs, result of the windowing bolt.
	 */
	public void execute(Tuple input) {
		ArrayList<Graph> graphList = (ArrayList<Graph>) input.getValue(0);
		//Graph graph = (Graph) input.getValue(0);
		QueryIterator queryIter = null;
		for (Graph g : graphList) {
			queryIter = Algebra.exec(this.opBGP, g); 
			while (queryIter.hasNext()) {
				Binding binding = queryIter.nextBinding();
				Values values = new Values();
				for (String str : this.outputFields) {
					Var aux = Var.alloc(str);
//					Var obsValue = Var.alloc("obsValue");
//					Var time = Var.alloc("time");
//					Var location = Var.alloc("location");
					Node auxNode = binding.get(aux);
//					Node obsValueNode = binding.get(obsValue);
//					Node timeNode = binding.get(time);
//					Node locationNode = binding.get(location);
	//				System.out.println(obsId + ": " + FmtUtils.stringForNode(obsIdNode) + ", " + 
	//						obsValue + ": " + FmtUtils.stringForNode(obsValueNode) + ", " + time + ": " + FmtUtils.stringForNode(timeNode)
	//						+ ", " + location + ": " + FmtUtils.stringForNode(locationNode));
					values.add(FmtUtils.stringForNode(auxNode));
				}	
				collector.emit(values);
//				collector.emit(new Values(FmtUtils.stringForNode(obsIdNode), FmtUtils.stringForNode(obsValueNode), 
//							FmtUtils.stringForNode(timeNode), FmtUtils.stringForNode(locationNode)));
			}
		}
		collector.ack(input);
	}