org.apache.jena.sparql.path.Path Java Examples

public Shape(ShapesGraph shapesGraph, SHShape shape) {
	this.shape = shape;
	this.shapesGraph = shapesGraph;
	Resource path = shape.getPath();
	this.path = path;
	this.deactivated = shape.isDeactivated();
	this.severity = shape.getSeverity();
	if(path != null) {			
		if(path.isAnon()) {
			jenaPath = (Path) SHACLPaths.getJenaPath(SHACLPaths.getPathString(path), path.getModel());
		}
		else {
			predicate = JenaUtil.asProperty(path);
		}
	}
	else {
		nodeShape = true;
	}
	collectTargets();
}
 

/**
 * Attempts to parse a given string into a Jena Path.
 * Throws an Exception if the string cannot be parsed.
 * @param string  the string to parse
 * @param model  the Model to operate on (for prefixes)
 * @return a Path or a Resource if this is a URI
 */
public static Object getJenaPath(String string, Model model) throws QueryParseException {
	Query query = ARQFactory.get().createQuery(model, "ASK { ?a \n" + string + "\n ?b }");
	Element element = query.getQueryPattern();
	if(element instanceof ElementGroup) {
		Element e = ((ElementGroup)element).getElements().get(0);
		if(e instanceof ElementPathBlock) {
			Path path = ((ElementPathBlock) e).getPattern().get(0).getPath();
			if(path instanceof P_Link && ((P_Link)path).isForward()) {
				return model.asRDFNode(((P_Link)path).getNode());
			}
			else {
				return path;
			}
		}
		else if(e instanceof ElementTriplesBlock) {
			return model.asRDFNode(((ElementTriplesBlock) e).getPattern().get(0).getPredicate());
		}
	}
	throw new QueryParseException("Not a SPARQL 1.1 Path expression", 2, 1);
}
 

@Override
public void visit(P_Alt pathAlt) {
    pathAlt.getLeft().visit(this);
    Path left = result;
    pathAlt.getRight().visit(this);
    Path right = result;
    result = new P_Alt(left, right);
}
 

@Override
public void visit(P_Seq pathSeq) {
    pathSeq.getLeft().visit(this);
    Path left = result;
    pathSeq.getRight().visit(this);
    Path right = result;
    result = new P_Seq(left, right);
}
 

private void visitPath(Path path, boolean needParensThisTime) {
    if (alwaysInnerParens) {
        needParensThisTime = true;
    }
    boolean b = needParens;
    needParens = needParensThisTime;
    path.visit(this);
    needParens = b;
}
 

private void printPathMod(String mod, Path path) {
    boolean doParens = (needParens || alwaysInnerParens);
    if (doParens) {
        out.print("(");
    }
    path.visit(this);
    if (doParens) {
        out.print(")");
    }
    out.print(mod);
}
 

@Override
public void visit(P_Inverse inversePath) {
    out.print("^");
    Path p = inversePath.getSubPath();
    boolean parens = true;
    if (p instanceof P_Link) {
        parens = false;
    }
    visitPath(p, parens);
}
 

public static void addValueNodes(RDFNode focusNode, Path path, Collection<RDFNode> results) {
	Set<Node> seen = new HashSet<>();
	Iterator<Node> it = PathEval.eval(focusNode.getModel().getGraph(), focusNode.asNode(), path, Context.emptyContext);
	while(it.hasNext()) {
		Node node = it.next();
		if(!seen.contains(node)) {
			seen.add(node);
			results.add(focusNode.getModel().asRDFNode(node));
		}
	}
}
 

/**
 * Constructs a PathEvaluator for an arbitrary SPARQL path (except single forward properties).
 * @param path  the path
 * @param shapesModel  the shapes Model
 */
public PathEvaluator(Path path, Model shapesModel) {
	this.jenaPath = path;
	isInverse = jenaPath instanceof P_Inverse && ((P_Inverse)jenaPath).getSubPath() instanceof P_Link;
	if(isInverse) {
		P_Link link = (P_Link) ((P_Inverse)jenaPath).getSubPath();
		predicate = shapesModel.getProperty(link.getNode().getURI());
	}
}
 

public PathExpression(RDFNode expr, Resource path, NodeExpression input) {
	super(expr, input);
	this.path = path;
	if(path.isAnon()) {
		pathString = SHACLPaths.getPathString(path);
		Path jenaPath = (Path) SHACLPaths.getJenaPath(pathString, path.getModel());
		eval = new PathEvaluator(jenaPath, expr.getModel());
	}
	else {
		pathString = FmtUtils.stringForRDFNode(path);
		eval = new PathEvaluator(JenaUtil.asProperty(path));
	}
	eval.setInput(input);
}
 

/**
 * @return latest normalized path
 */
public Path getResult() {
    return result;
}
 

public static void write(IndentedWriter out, Path path, SerializationContext context) {
    PathWriterWorker w = new PathWriterWorker(out, context);
    path.visit(w);
    out.flush();
}
 

private void visitPath(Path path) {
    visitPath(path, true);
}
 

public Path getJenaPath() {
	return jenaPath;
}
 

private static Path readPath(Resource resource) {
    if (resource.isURIResource()) {
        return new P_Link(resource.asNode());
    }

    if (RdfListUtils.isList(resource)) {
        return RdfListUtils.getListItemsOrEmpty(resource).stream()
                .filter(RDFNode::isResource)
                .map(RDFNode::asResource)
                .map(ShapePathReader::readPath)
                .reduce(PathFactory::pathSeq)
                .orElseThrow(() -> new IllegalArgumentException("Sequence path invalid"));
    }

    Resource inverse = resource.getPropertyResourceValue(SHACL.inversePath);
    if ( inverse != null ) {
        return PathFactory.pathInverse(readPath(inverse));
    }

    Resource alternate = resource.getPropertyResourceValue(SHACL.alternativePath);
    if ( alternate != null && RdfListUtils.isList(alternate)) {
        return RdfListUtils.getListItemsOrEmpty(alternate).stream()
                .filter(RDFNode::isResource)
                .map(RDFNode::asResource)
                .map(ShapePathReader::readPath)
                .reduce(PathFactory::pathAlt)
                .orElseThrow(() -> new IllegalArgumentException("Sequence path invalid"));
    }

    Resource zeroOrOne = resource.getPropertyResourceValue(SHACL.zeroOrOnePath);
    if ( zeroOrOne != null ) {
        return PathFactory.pathZeroOrOne(readPath(zeroOrOne));
    }

    Resource zeroOrMore = resource.getPropertyResourceValue(SHACL.zeroOrMorePath);
    if ( zeroOrMore != null ) {
        return PathFactory.pathZeroOrMore1(readPath(zeroOrMore));
    }

    Resource oneOrMore = resource.getPropertyResourceValue(SHACL.oneOrMorePath);
    if ( oneOrMore != null ) {
        return PathFactory.pathOneOrMore1(readPath(oneOrMore));
    }
    throw new IllegalArgumentException("Wrong SHACL Path");
}
 

Path getJenaPath();