/** * Creates a {@link org.eclipse.rdf4j.model.IRI}. * @param iri a base string for the {@link org.eclipse.rdf4j.model.IRI} * @return a valid {@link org.eclipse.rdf4j.model.IRI} */ public static org.eclipse.rdf4j.model.IRI iri(String iri) { return valueFactory.createIRI(iri); }
/** * Creates a {@link org.eclipse.rdf4j.model.IRI}. * @param namespace a base namespace for the {@link org.eclipse.rdf4j.model.IRI} * @param localName a local name to associate with the namespace * @return a valid {@link org.eclipse.rdf4j.model.IRI} */ public static org.eclipse.rdf4j.model.IRI iri(String namespace, String localName) { return valueFactory.createIRI(namespace, localName); }
/******************************************************************************************************************* * * ******************************************************************************************************************/ @Nonnull public static IRI uriFor (final @Nonnull URL url) { return FACTORY.createIRI(url.toString()); }
public void writeTripleUriObject(String subjectUri, IRI predicate, String objectUri) throws RDFHandlerException { writeTripleValueObject(subjectUri, predicate, factory.createIRI(objectUri)); }
/** * @return a valid sesame IRI or null if any exception occurred */ @Override public IRI createIRI(String namespace, String localName) { if (namespace == null || localName == null) return null; return wrappedFactory.createIRI(RDFUtils.fixIRIWithException(namespace), localName); }
private IRI readURI() throws IOException { String uri = readString(); return valueFactory.createIRI(uri); }
@Nonnull public static IRI trackIriFor (final @Nonnull Id id) { return FACTORY.createIRI("urn:bluemarine:track:" + id.stringValue()); }
@Nonnull public static IRI recordIriFor (final @Nonnull Id id) { return FACTORY.createIRI("urn:bluemarine:record:" + id.stringValue()); }
@Nonnull public static IRI artistIriFor (final @Nonnull Id id) { return FACTORY.createIRI("urn:bluemarine:artist:" + id.stringValue()); } }
public SpinMagicPropertyInterpreter(SpinParser parser, TripleSource tripleSource, TupleFunctionRegistry tupleFunctionRegistry, AbstractFederatedServiceResolver serviceResolver) { this.parser = parser; this.tripleSource = tripleSource; this.tupleFunctionRegistry = tupleFunctionRegistry; this.serviceResolver = serviceResolver; this.spinServiceUri = tripleSource.getValueFactory().createIRI(SPIN_SERVICE); }
private IRI readQName() throws IOException { int nsID = in.readInt(); String localName = readString(); return valueFactory.createIRI(namespaceArray[nsID], localName); }
@Override public IRI createIRI(String iri) { try { if (!new ParsedIRI(iri).isAbsolute()) { throw new IllegalArgumentException("IRI must be absolute"); } return delegate.createIRI(iri); } catch (URISyntaxException e) { throw new IllegalArgumentException(e); } }
/** * @param iri IRI to fix * @return a valid sesame IRI or null if any exception occurred */ public IRI fixIRI(String iri) { try { return wrappedFactory.createIRI(RDFUtils.fixIRIWithException(iri)); } catch (Exception e) { reportError(e); return null; } }
private Resource getContext(String repositoryID) { String location; try { location = manager.getLocation().toURI().toString(); } catch (MalformedURLException | URISyntaxException e) { assert false; location = "urn:" + repositoryID; } String url = Protocol.getRepositoryLocation(location, repositoryID); return getValueFactory().createIRI(url + "#" + repositoryID); }
@Override public ValueConstant visit(ASTURI node, Object data) throws VisitorException { return new ValueConstant(valueFactory.createIRI(node.getValue())); }
public void applyRootConcepts(KnowledgeBaseProfile aProfile) { if (aProfile.getRootConcepts() == null) { setRootConcepts(new ArrayList<>()); } else { ValueFactory vf = SimpleValueFactory.getInstance(); for (String rootConcept : aProfile.getRootConcepts()) { rootConcepts.add(vf.createIRI(rootConcept)); } } }
private Function getFunction(String name, TripleSource tripleSource, FunctionRegistry functionRegistry) throws RDF4JException { Function func = functionRegistry.get(name).orElse(null); if (func == null) { IRI funcUri = tripleSource.getValueFactory().createIRI(name); func = parser.parseFunction(funcUri, tripleSource); functionRegistry.add(func); } return func; } }
public static Resource getResource(ObjectConstant obj) { if (obj instanceof BNode) return fact.createBNode(((BNode)obj).getName()); else if (obj instanceof IRIConstant) return fact.createIRI(((IRIConstant) obj).getIRI().getIRIString()); else return null; //throw new IllegalArgumentException("Invalid constant as subject!" + obj); }
@Override public Resource export(Model m) { Resource implNode = super.export(m); m.setNamespace("sparql", NAMESPACE); if (getQueryEndpointUrl() != null) { m.add(implNode, QUERY_ENDPOINT, vf.createIRI(getQueryEndpointUrl())); } if (getUpdateEndpointUrl() != null) { m.add(implNode, UPDATE_ENDPOINT, vf.createIRI(getUpdateEndpointUrl())); } return implNode; }
@Override public final void addNonLiteral(String subj, String pred, String obj, String graph) { if (graph == null) { addNonLiteral(subj, pred, obj); } else { addQuad(convertNonLiteral(subj), valueFactory.createIRI(pred), convertNonLiteral(obj), convertNonLiteral(graph)); } }