Java BlankNodeOrIRI类代码示例

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
/**
 * Create an Authorization object from an RDF graph.
 *
 * @param identifier the subject IRI
 * @param graph the RDF graph
 */
public Authorization(final BlankNodeOrIRI identifier, final Graph graph) {
    requireNonNull(identifier, "The Authorization identifier may not be null!");
    requireNonNull(graph, "The input graph may not be null!");

    this.identifier = identifier;

    this.dataMap.put(ACL.agent, new HashSet<>());
    this.dataMap.put(ACL.agentClass, new HashSet<>());
    this.dataMap.put(ACL.agentGroup, new HashSet<>());
    this.dataMap.put(ACL.mode, new HashSet<>());
    this.dataMap.put(ACL.accessTo, new HashSet<>());
    this.dataMap.put(ACL.default_, new HashSet<>());

    graph.stream(identifier, null, null).filter(triple -> dataMap.containsKey(triple.getPredicate()))
        .filter(triple -> triple.getObject() instanceof IRI)
        .forEachOrdered(triple -> dataMap.get(triple.getPredicate()).add((IRI) triple.getObject()));
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
/**
 * Create an Authorization object from an RDF graph
 * @param identifier the subject IRI
 * @param graph the RDF graph
 */
public Authorization(final BlankNodeOrIRI identifier, final Graph graph) {
    requireNonNull(identifier, "The Authorization identifier may not be null!");
    requireNonNull(graph, "The input graph may not be null!");

    this.identifier = identifier;

    this.dataMap.put(ACL.agent, new HashSet<>());
    this.dataMap.put(ACL.agentClass, new HashSet<>());
    this.dataMap.put(ACL.agentGroup, new HashSet<>());
    this.dataMap.put(ACL.mode, new HashSet<>());
    this.dataMap.put(ACL.accessTo, new HashSet<>());
    this.dataMap.put(ACL.default_, new HashSet<>());

    graph.stream(identifier, null, null).filter(triple -> dataMap.containsKey(triple.getPredicate()))
        .filter(triple -> triple.getObject() instanceof IRI)
        .forEachOrdered(triple -> dataMap.get(triple.getPredicate()).add((IRI) triple.getObject()));
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public ClosableIterable<Triple> iterate(final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) {
    return new ClosableIterable<Triple>() {
        @SuppressWarnings("unchecked")
        @Override
        public Iterator<Triple> iterator() {
            // double-cast to fight Java generics..
            final Stream<? extends Triple> s = stream(subject, predicate, object);
            return (Iterator<Triple>) s.iterator();
        }

        @Override
        public void close() throws Exception {
            // no-op as Model don't have transaction
        }
    };
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public void add(final Quad quad) {
    final BlankNodeOrIRI newGraph = (BlankNodeOrIRI) internallyMap(quad.getGraphName().orElse(null));
    final BlankNodeOrIRI newSubject = (BlankNodeOrIRI) internallyMap(quad.getSubject());
    final IRI newPredicate = (IRI) internallyMap(quad.getPredicate());
    final RDFTerm newObject = internallyMap(quad.getObject());
    // Check if any of the object references changed during the mapping, to
    // avoid creating a new Quad object if possible
    if (newGraph == quad.getGraphName().orElse(null) && newSubject == quad.getSubject()
            && newPredicate == quad.getPredicate() && newObject == quad.getObject()) {
        quads.add(quad);
    } else {
        // Make a new Quad with our mapped instances
        final Quad result = factory.createQuad(newGraph, newSubject, newPredicate, newObject);
        quads.add(result);
    }
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
String asJsonLdString(final BlankNodeOrIRI blankNodeOrIRI) {
    if (blankNodeOrIRI == null) {
        return null;
    }
    if (blankNodeOrIRI instanceof IRI) {
        return ((IRI) blankNodeOrIRI).getIRIString();
    } else if (blankNodeOrIRI instanceof BlankNode) {
        final BlankNode blankNode = (BlankNode) blankNodeOrIRI;
        final String ref = blankNode.uniqueReference();
        if (ref.startsWith(bnodePrefix)) {
            // One of ours (but possibly not a JsonLdBlankNode) -
            // we can use the suffix directly
            return ref.replace(bnodePrefix, "");
        }
        // Map to unique bnode identifier, e.g.
        // _:0dbd92ee-ab1a-45e7-bba2-7ade54f87ec5
        final UUID uuid = UUID.nameUUIDFromBytes(ref.getBytes(StandardCharsets.UTF_8));
        return "_:" + uuid;
    } else {
        throw new IllegalArgumentException("Expected a BlankNode or IRI, not: " + blankNodeOrIRI);
    }
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
/**
 * Get the PROV.endedAtTime quad, wrapped in a Stream
 * @param identifier the identifier
 * @param dataset the dataset
 * @param time the time
 * @return the quad
 */
public static Stream<Quad> endedAtQuad(final IRI identifier, final Dataset dataset, final Instant time) {
    return dataset.stream(of(PreferAudit), identifier, wasGeneratedBy, null)
        .map(Quad::getObject).filter(term -> term instanceof BlankNodeOrIRI)
        .map(term -> (BlankNodeOrIRI) term)
        .map(term -> (Quad) rdf.createQuad(PreferAudit, term, endedAtTime,
                rdf.createLiteral(time.toString(), dateTime))).limit(1);
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public RDF4JTriple createTriple(final BlankNodeOrIRI subject, final org.apache.commons.rdf.api.IRI predicate, final RDFTerm object)
        throws IllegalArgumentException {
    final Statement statement = getValueFactory().createStatement(
            (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
            asValue(object));
    return asTriple(statement);
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public Quad createQuad(final BlankNodeOrIRI graphName, final BlankNodeOrIRI subject, final org.apache.commons.rdf.api.IRI predicate,
        final RDFTerm object) throws IllegalArgumentException {
    final Statement statement = getValueFactory().createStatement(
            (org.eclipse.rdf4j.model.Resource) asValue(subject), (org.eclipse.rdf4j.model.IRI) asValue(predicate),
            asValue(object), (org.eclipse.rdf4j.model.Resource) asValue(graphName));
    return asQuad(statement);
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public void add(final BlankNodeOrIRI graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) {
    final Resource context = (Resource) rdf4jTermFactory.asValue(graphName);
    final Resource subj = (Resource) rdf4jTermFactory.asValue(subject);
    final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate);
    final Value obj = rdf4jTermFactory.asValue(object);
    try (RepositoryConnection conn = getRepositoryConnection()) {
        conn.add(subj, pred, obj, context);
        conn.commit();
    }
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public boolean contains(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) {
    final Resource subj = (Resource) rdf4jTermFactory.asValue(subject);
    final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate);
    final Value obj = rdf4jTermFactory.asValue(object);
    final Resource[] contexts = asContexts(graphName);
    try (RepositoryConnection conn = getRepositoryConnection()) {
        return conn.hasStatement(subj, pred, obj, includeInferred, contexts);
    }
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
private Resource[] asContexts(final Optional<BlankNodeOrIRI> graphName) {
    Resource[] contexts;
    if (graphName == null) {
        // no contexts == any contexts
        contexts = new Resource[0];
    } else {
        final BlankNodeOrIRI g = graphName.orElse(null);
        final Resource context = (Resource) rdf4jTermFactory.asValue(g);
        contexts = new Resource[] { context };
    }
    return contexts;
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public void remove(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) {
    final Resource subj = (Resource) rdf4jTermFactory.asValue(subject);
    final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate);
    final Value obj = rdf4jTermFactory.asValue(object);
    final Resource[] contexts = asContexts(graphName);

    try (RepositoryConnection conn = getRepositoryConnection()) {
        conn.remove(subj, pred, obj, contexts);
        conn.commit();
    }
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public ClosableIterable<Quad> iterate(final Optional<BlankNodeOrIRI> graphName, final BlankNodeOrIRI subject, final IRI predicate,
        final RDFTerm object) throws ConcurrentModificationException, IllegalStateException {
    final Resource[] contexts = asContexts(graphName);
    final Resource subj = (Resource) rdf4jTermFactory.asValue(subject);
    final org.eclipse.rdf4j.model.IRI pred = (org.eclipse.rdf4j.model.IRI) rdf4jTermFactory.asValue(predicate);
    final Value obj = rdf4jTermFactory.asValue(object);
    return new ConvertedStatements<>(this::getRepositoryConnection, rdf4jTermFactory::asQuad, subj, pred, obj,
            contexts);
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public Optional<Graph> getGraph(final BlankNodeOrIRI graphName) {
    // NOTE: May be null to indicate default context
    final Resource context = (Resource) rdf4jTermFactory.asValue(graphName);
    // NOTE: We carry over the 'salt' as the graph's BlankNode should be
    // equal to our BlankNodes
    return Optional.of(new RepositoryGraphImpl(repository, salt, false, includeInferred, context));
}
 

import org.apache.commons.rdf.api.BlankNodeOrIRI; //导入依赖的package包/类
@Override
public Stream<BlankNodeOrIRI> getGraphNames() {
   final RepositoryConnection conn = getRepositoryConnection();
   final RepositoryResult<Resource> contexts = conn.getContextIDs();
    return Iterations.stream(contexts).map(g -> (BlankNodeOrIRI) rdf4jTermFactory.asRDFTerm(g))
            .onClose(conn::close);
}