import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@Test
public void testUpdate() {
    final Graph graph = rdf.createGraph();
    getTriples().forEach(graph::add);
    assertEquals(3L, graph.size());
    service.update(graph, "DELETE WHERE { ?s <http://purl.org/dc/terms/title> ?o }", "test:info");
    assertEquals(2L, graph.size());
    service.update(graph, "INSERT { " +
            "<> <http://purl.org/dc/terms/title> \"Other title\" } WHERE {}",
            "trellis:repository/resource");
    assertEquals(3L, graph.size());
    service.update(graph, "DELETE WHERE { ?s ?p ?o };" +
            "INSERT { <> <http://purl.org/dc/terms/title> \"Other title\" } WHERE {}",
            "trellis:repository");
    assertEquals(1L, graph.size());
    assertEquals("<trellis:repository>", graph.stream().findFirst().map(Triple::getSubject)
            .map(RDFTerm::ntriplesString).get());
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@BeforeEach
public void setUp() {
    initMocks(this);
    when(mockBinaryService.getIdentifierSupplier()).thenReturn(() -> "file:" + randomUUID());
    when(mockResourceService.put(any(IRI.class), any(IRI.class), any(Dataset.class)))
        .thenReturn(completedFuture(true));
    when(mockResourceService.skolemize(any(Literal.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(IRI.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(BlankNode.class))).thenAnswer(inv ->
            rdf.createIRI(TRELLIS_BNODE_PREFIX + ((BlankNode) inv.getArgument(0)).uniqueReference()));

    when(mockRequest.getSession()).thenReturn(new HttpSession());
    when(mockRequest.getPath()).thenReturn("");
    when(mockRequest.getBaseUrl()).thenReturn(baseUrl);
    when(mockResourceService.toInternal(any(RDFTerm.class), any())).thenAnswer(inv -> {
        final RDFTerm term = (RDFTerm) inv.getArgument(0);
        if (term instanceof IRI) {
            final String iri = ((IRI) term).getIRIString();
            if (iri.startsWith(baseUrl)) {
                return rdf.createIRI(TRELLIS_PREFIX + iri.substring(baseUrl.length()));
            }
        }
        return term;
    });
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的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.RDFTerm; //导入依赖的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.RDFTerm; //导入依赖的package包/类
private <T extends RDFTerm> RDFTerm internallyMap(final T object) {
    if (object == null || object instanceof SimpleRDFTerm) {
        return object;
    }
    if (object instanceof BlankNode && !(object instanceof BlankNodeImpl)) {
        final BlankNode blankNode = (BlankNode) object;
        // This guarantees that adding the same BlankNode multiple times to
        // this graph will generate a local object that is mapped to an
        // equivalent object, based on the code in the package private
        // BlankNodeImpl class
        return factory.createBlankNode(blankNode.uniqueReference());
    } else if (object instanceof IRI && !(object instanceof IRIImpl)) {
        final IRI iri = (IRI) object;
        return factory.createIRI(iri.getIRIString());
    } else if (object instanceof Literal && !(object instanceof LiteralImpl)) {
        final Literal literal = (Literal) object;
        if (literal.getLanguageTag().isPresent()) {
            return factory.createLiteral(literal.getLexicalForm(), literal.getLanguageTag().get());
        }
        return factory.createLiteral(literal.getLexicalForm(), (IRI) internallyMap(literal.getDatatype()));
    } else {
        throw new IllegalArgumentException("Not a BlankNode, IRI or Literal: " + object);
    }
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Skolemize a blank node.
 *
 * @param term the RDF term
 * @return a skolemized node, if a blank node; otherwise the original term
 */
default RDFTerm skolemize(final RDFTerm term) {
    if (term instanceof BlankNode) {
        return getInstance().createIRI(TRELLIS_BNODE_PREFIX + ((BlankNode) term).uniqueReference());
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Un-skolemize a blank node.
 *
 * @param term the RDF term
 * @return a blank node, if a previously-skolemized node; otherwise the original term
 */
default RDFTerm unskolemize(final RDFTerm term) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(TRELLIS_BNODE_PREFIX)) {
            return getInstance().createBlankNode(iri.substring(TRELLIS_BNODE_PREFIX.length()));
        }
    }
    return term;

}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Return an "internal" representation of an RDF term.
 *
 * @param <T> the type of RDF term
 * @param term the RDF term
 * @param baseUrl the base URL of the domain
 * @return the "internal" RDF term
 */
default <T extends RDFTerm> T toInternal(final T term, final String baseUrl) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(baseUrl)) {
            @SuppressWarnings("unchecked")
            final T t = (T) getInstance().createIRI(TRELLIS_PREFIX + iri.substring(baseUrl.length()));
            return t;
        }
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Return an "external" representation of an RDF term.
 *
 * @param <T> the type of RDF term
 * @param term the RDF term
 * @param baseUrl the base URL of the domain
 * @return the "external" RDF term
 */
default <T extends RDFTerm> T toExternal(final T term, final String baseUrl) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(TRELLIS_PREFIX)) {
            @SuppressWarnings("unchecked")
            final T t = (T) getInstance().createIRI(baseUrl + iri.substring(TRELLIS_PREFIX.length()));
            return t;
        }
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
private Predicate<IRI> isAgentInGroup(final IRI agent) {
    return group -> resourceService.get(cleanIdentifier(group)).filter(res -> {
        try (final Stream<RDFTerm> triples = res.stream(Trellis.PreferUserManaged)
                .filter(t -> t.getSubject().equals(group) && t.getPredicate().equals(VCARD.hasMember))
                .map(Triple::getObject)) {
            return triples.anyMatch(agent::equals);
        }
    }).isPresent();
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@BeforeEach
public void setUp() {
    initMocks(this);
    when(mockResource.getInteractionModel()).thenReturn(LDP.RDFSource);
    when(mockResource.getBinary()).thenReturn(empty());
    when(mockResource.getModified()).thenReturn(time);
    when(mockBinaryService.getIdentifierSupplier()).thenReturn(() -> "file:" + randomUUID());
    when(mockResourceService.put(any(IRI.class), any(IRI.class), any(Dataset.class)))
        .thenReturn(completedFuture(true));
    when(mockResourceService.skolemize(any(Literal.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(IRI.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(BlankNode.class))).thenAnswer(inv ->
            rdf.createIRI(TRELLIS_BNODE_PREFIX + ((BlankNode) inv.getArgument(0)).uniqueReference()));

    when(mockLdpRequest.getRequest()).thenReturn(mockRequest);
    when(mockLdpRequest.getPath()).thenReturn("resource");
    when(mockLdpRequest.getBaseUrl()).thenReturn(baseUrl);
    when(mockLdpRequest.getSession()).thenReturn(new HttpSession());
    when(mockResourceService.toInternal(any(RDFTerm.class), any())).thenAnswer(inv -> {
        final RDFTerm term = (RDFTerm) inv.getArgument(0);
        if (term instanceof IRI) {
            final String iri = ((IRI) term).getIRIString();
            if (iri.startsWith(baseUrl)) {
                return rdf.createIRI(TRELLIS_PREFIX + iri.substring(baseUrl.length()));
            }
        }
        return term;
    });
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@BeforeEach
public void setUp() {
    initMocks(this);
    when(mockResource.getModified()).thenReturn(time);
    when(mockResource.getInteractionModel()).thenReturn(LDP.RDFSource);
    when(mockResource.getIdentifier()).thenReturn(identifier);
    when(mockResourceService.put(any(IRI.class), any(IRI.class), any(Dataset.class)))
        .thenReturn(completedFuture(true));
    when(mockResourceService.skolemize(any(Literal.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(IRI.class))).then(returnsFirstArg());
    when(mockResourceService.skolemize(any(BlankNode.class))).thenAnswer(inv ->
            rdf.createIRI(TRELLIS_BNODE_PREFIX + ((BlankNode) inv.getArgument(0)).uniqueReference()));
    when(mockLdpRequest.getRequest()).thenReturn(mockRequest);
    when(mockLdpRequest.getPath()).thenReturn("resource");
    when(mockLdpRequest.getBaseUrl()).thenReturn(baseUrl);
    when(mockLdpRequest.getHeaders()).thenReturn(mockHttpHeaders);
    when(mockHttpHeaders.getAcceptableMediaTypes()).thenReturn(singletonList(TEXT_TURTLE_TYPE));
    when(mockResourceService.toInternal(any(RDFTerm.class), any())).thenAnswer(inv -> {
        final RDFTerm term = (RDFTerm) inv.getArgument(0);
        final String base = (String) inv.getArgument(1);
        if (term instanceof IRI) {
            final String iri = ((IRI) term).getIRIString();
            if (iri.startsWith(base)) {
                return rdf.createIRI(TRELLIS_PREFIX + iri.substring(base.length()));
            }
        }
        return term;
    });
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@BeforeEach
public void setUp() {
    initMocks(this);
    final IRI iri = rdf.createIRI("trellis:repo");
    when(mockResource.getModified()).thenReturn(time);
    when(mockResource.getIdentifier()).thenReturn(iri);
    when(mockResource.getMementos()).thenReturn(emptyList());
    when(mockResource.getExtraLinkRelations()).thenAnswer(inv -> Stream.empty());

    when(mockResourceService.skolemize(any(BlankNode.class)))
        .thenReturn(rdf.createIRI(TRELLIS_BNODE_PREFIX + "foo"));
    when(mockResourceService.skolemize(eq(iri))).thenReturn(iri);
    when(mockResourceService.skolemize(eq(AS.Delete))).thenReturn(AS.Delete);
    when(mockResourceService.skolemize(eq(PROV.Activity))).thenReturn(PROV.Activity);
    when(mockResourceService.skolemize(eq(Trellis.AnonymousAgent))).thenReturn(Trellis.AnonymousAgent);
    when(mockResourceService.skolemize(eq(date))).thenReturn(date);
    when(mockResourceService.put(eq(iri), any(IRI.class), any(Dataset.class))).thenReturn(completedFuture(true));

    when(mockLdpRequest.getSession()).thenReturn(mockSession);
    when(mockLdpRequest.getBaseUrl()).thenReturn(baseUrl);
    when(mockLdpRequest.getPath()).thenReturn("/");
    when(mockLdpRequest.getRequest()).thenReturn(mockRequest);

    when(mockSession.getCreated()).thenReturn(time);
    when(mockSession.getAgent()).thenReturn(Trellis.AnonymousAgent);
    when(mockSession.getDelegatedBy()).thenReturn(empty());
    when(mockResourceService.toInternal(any(RDFTerm.class), any())).thenAnswer(inv -> {
        final RDFTerm term = (RDFTerm) inv.getArgument(0);
        final String base = (String) inv.getArgument(1);
        if (term instanceof IRI) {
            final String iriString = ((IRI) term).getIRIString();
            if (iriString.startsWith(base)) {
                return rdf.createIRI(TRELLIS_PREFIX + iriString.substring(base.length()));
            }
        }
        return term;
    });
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Skolemize a blank node
 * @param term the RDF term
 * @return a skolemized node, if a blank node; otherwise the original term
 */
default RDFTerm skolemize(final RDFTerm term) {
    if (term instanceof BlankNode) {
        return getInstance().createIRI(TRELLIS_BNODE_PREFIX + ((BlankNode) term).uniqueReference());
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Un-skolemize a blank node
 * @param term the RDF term
 * @return a blank node, if a previously-skolemized node; otherwise the original term
 */
default RDFTerm unskolemize(final RDFTerm term) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(TRELLIS_BNODE_PREFIX)) {
            return getInstance().createBlankNode(iri.substring(TRELLIS_BNODE_PREFIX.length()));
        }
    }
    return term;

}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Return an "internal" representation of an RDF term
 * @param <T> the type of RDF term
 * @param term the RDF term
 * @param baseUrl the base URL of the domain
 * @return the "internal" RDF term
 */
default <T extends RDFTerm> T toInternal(final T term, final String baseUrl) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(baseUrl)) {
            @SuppressWarnings("unchecked")
            final T t = (T) getInstance().createIRI(TRELLIS_PREFIX + iri.substring(baseUrl.length()));
            return t;
        }
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Return an "external" representation of an RDF term
 * @param <T> the type of RDF term
 * @param term the RDF term
 * @param baseUrl the base URL of the domain
 * @return the "external" RDF term
 */
default <T extends RDFTerm> T toExternal(final T term, final String baseUrl) {
    if (term instanceof IRI) {
        final String iri = ((IRI) term).getIRIString();
        if (iri.startsWith(TRELLIS_PREFIX)) {
            @SuppressWarnings("unchecked")
            final T t = (T) getInstance().createIRI(baseUrl + iri.substring(TRELLIS_PREFIX.length()));
            return t;
        }
    }
    return term;
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
@Test
public void testEndedAtQuad() {
    final Dataset dataset = rdf.createDataset();
    final Instant time = now();
    dataset.add(rdf.createQuad(Trellis.PreferAudit, identifier, PROV.wasGeneratedBy, rdf.createBlankNode()));

    final List<Quad> quads = endedAtQuad(identifier, dataset, time).collect(toList());
    assertEquals(1L, quads.size());
    final RDFTerm literal = quads.get(0).getObject();
    assertTrue(literal instanceof Literal);
    assertEquals(time.toString(), ((Literal) literal).getLexicalForm());
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的package包/类
/**
 * Adapt a Commons RDF {@link RDFTerm} as a RDF4J {@link Value}.
 * <p>
 * The value will be of the same kind as the term, e.g. a
 * {@link org.apache.commons.rdf.api.BlankNode} is converted to a
 * {@link org.eclipse.rdf4j.model.BNode}, a
 * {@link org.apache.commons.rdf.api.IRI} is converted to a
 * {@link org.eclipse.rdf4j.model.IRI} and a
 * {@link org.apache.commons.rdf.api.Literal} is converted to a
 * {@link org.eclipse.rdf4j.model.Literal}.
 * <p>
 * If the provided {@link RDFTerm} is <code>null</code>, then the returned
 * value is <code>null</code>.
 * <p>
 * If the provided term is an instance of {@link RDF4JTerm}, then the
 * {@link RDF4JTerm#asValue()} is returned without any conversion. Note that
 * this could mean that a {@link Value} from a different kind of
 * {@link ValueFactory} could be returned.
 *
 * @param term
 *            RDFTerm to adapt to RDF4J Value
 * @return Adapted RDF4J {@link Value}
 */
public Value asValue(final RDFTerm term) {
    if (term == null) {
        return null;
    }
    if (term instanceof RDF4JTerm) {
        // One of our own - avoid converting again.
        // (This is crucial to avoid double-escaping in BlankNode)
        return ((RDF4JTerm) term).asValue();
    }
    if (term instanceof org.apache.commons.rdf.api.IRI) {
        final org.apache.commons.rdf.api.IRI iri = (org.apache.commons.rdf.api.IRI) term;
        return getValueFactory().createIRI(iri.getIRIString());
    }
    if (term instanceof org.apache.commons.rdf.api.Literal) {
        final org.apache.commons.rdf.api.Literal literal = (org.apache.commons.rdf.api.Literal) term;
        final String label = literal.getLexicalForm();
        if (literal.getLanguageTag().isPresent()) {
            final String lang = literal.getLanguageTag().get();
            return getValueFactory().createLiteral(label, lang);
        }
        final org.eclipse.rdf4j.model.IRI dataType = (org.eclipse.rdf4j.model.IRI) asValue(literal.getDatatype());
        return getValueFactory().createLiteral(label, dataType);
    }
    if (term instanceof BlankNode) {
        // This is where it gets tricky to support round trips!
        final BlankNode blankNode = (BlankNode) term;
        // FIXME: The uniqueReference might not be a valid BlankNode
        // identifier..
        // does it have to be in RDF4J?
        return getValueFactory().createBNode(blankNode.uniqueReference());
    }
    throw new IllegalArgumentException("RDFTerm was not an IRI, Literal or BlankNode: " + term.getClass());
}
 

import org.apache.commons.rdf.api.RDFTerm; //导入依赖的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);
}