Java RDF类代码示例

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
/**
 * Parse a string into a Quad
 * @param rdf the RDF object
 * @param line the line of text
 * @return the Quad
 */
public static Optional<Quad> stringToQuad(final RDF rdf, final String line) {
    final DatasetGraph dataset = create();
    try {
        fromString(line).lang(NQUADS).parse(dataset);
    } catch (final RiotException ex) {
        LOGGER.warn("Skipping invalid data value: {}", line);
        return empty();
    }
    final Iterator<org.apache.jena.sparql.core.Quad> i = dataset.find();
    if (i.hasNext()) {
        return of(i.next()).map(x -> asQuad(rdf, x));
    }
    return empty();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
/**
 * Create an iterator that reads a file line-by-line in reverse
 * @param rdf the RDF object
 * @param file the file
 * @param identifier the identifier
 * @param time the time
 */
public StreamReader(final RDF rdf, final File file, final IRI identifier, final Instant time) {
    this.rdf = rdf;
    this.time = time;
    this.identifier = identifier;
    try {
        this.reader = new ReversedLinesFileReader(file, UTF_8);
        this.line = reader.readLine();
    } catch (final IOException ex) {
        throw new UncheckedIOException(ex);
    }
    bufferIter = readPatch();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Test
public void testServiceLoaderLookup() {
    final ServiceLoader<RDF> loader = ServiceLoader.load(RDF.class);
    for (final RDF impl : loader) {
        if (impl instanceof RDF4J) {
            return; // yay
        }
    }
    fail("RDF4J not found in ServiceLoader");
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Test
public void testServiceLoaderLookup() {
    final ServiceLoader<RDF> loader = ServiceLoader.load(RDF.class);
    for (final RDF impl : loader) {
        if (impl instanceof SimpleRDF) {
            return; // yay
        }
    }
    fail("SimpleRDF not found in ServiceLoader");
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
protected void parseSynchronusly() throws IOException, IllegalStateException, RDFParseException {
    // From parseSynchronusly both of these are always present
    final RDF factory = getRdfTermFactory().get();
    final Consumer<Quad> t = getTarget();

    // well - each parsing is unique. This should hopefully
    // catch any accidental double parsing
    final IRI parsing = factory.createIRI("urn:uuid:" + UUID.randomUUID());
    t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/greeting"),
            factory.createLiteral("Hello world")));

    // Now we'll expose the finalized AbstractRDFParser settings
    // so they can be inspected by the junit test

    if (getSourceIri().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/source"),
                getSourceIri().get()));
    }
    if (getSourceFile().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/source"),
                factory.createIRI(getSourceFile().get().toUri().toString())));
    }
    if (getSourceInputStream().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/source"),
                factory.createBlankNode()));
    }

    if (getBase().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/base"), getBase().get()));
    }
    if (getContentType().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/contentType"),
                factory.createLiteral(getContentType().get())));
    }
    if (getContentTypeSyntax().isPresent()) {
        t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/contentTypeSyntax"),
                factory.createLiteral(getContentTypeSyntax().get().name())));
    }
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Test
public void testServiceLoaderLookup() {
    final ServiceLoader<RDF> loader = ServiceLoader.load(RDF.class);
    for (final RDF impl : loader) {
        if (impl instanceof JsonLdRDF) {
            return; // yay
        }
    }
    fail("JsonLdRDF not found in ServiceLoader");
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
/**
 * Convert from Jena {@link Node} to any Commons RDF implementation.
 * <p>
 * Note that if the {@link Node#isBlank()}, then the factory's
 * {@link RDF#createBlankNode(String)} will be used, meaning that care
 * should be taken if reusing an {@link RDF} instance for multiple
 * conversion sessions.
 *
 * @see #asRDFTerm(Node)
 *
 * @param factory
 *            {@link RDF} to use for creating {@link RDFTerm}.
 * @param node
 *            The Jena Node to adapt. It's {@link Node#isConcrete()} must be
 *            <code>true</code>.
 * @return Adapted {@link RDFTerm}
 * @throws ConversionException
 *             If the {@link Node} can't be represented as an
 *             {@link RDFTerm}, e.g. if the node is not concrete or
 *             represents a variable in Jena.
 */
public static RDFTerm asRDFTerm(final RDF factory, final Node node) {
    if (node == null) {
        return null;
    }
    if (factory instanceof JenaRDF) {
        // No need to convert, just wrap
        return ((JenaRDF) factory).asRDFTerm(node);
    }
    if (node.isURI()) {
        return factory.createIRI(node.getURI());
    }
    if (node.isLiteral()) {
        final String lang = node.getLiteralLanguage();
        if (lang != null && !lang.isEmpty()) {
            return factory.createLiteral(node.getLiteralLexicalForm(), lang);
        }
        if (node.getLiteralDatatype().equals(XSDDatatype.XSDstring)) {
            return factory.createLiteral(node.getLiteralLexicalForm());
        }
        final IRI dt = factory.createIRI(node.getLiteralDatatype().getURI());
        return factory.createLiteral(node.getLiteralLexicalForm(), dt);
    }
    if (node.isBlank()) {
        // The factory
        return factory.createBlankNode(node.getBlankNodeLabel());
    }
    throw new ConversionException("Node is not a concrete RDF Term: " + node);
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Test
public void testServiceLoaderLookup() {
    final ServiceLoader<RDF> loader = ServiceLoader.load(RDF.class);
    for (final RDF impl : loader) {
        if (impl instanceof JenaRDF) {
            return; // yay
        }
    }
    fail("JenaRDF not found in ServiceLoader");
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Test
public void datasetImplToStringTest() {
    RDF rdf = createFactory();
    JenaDataset jena = (JenaDataset) rdf.createDataset();
    final IRI graph = rdf.createIRI("http://example.com/");
    final IRI s = rdf.createIRI("http://example.com/s");
    final IRI p = rdf.createIRI("http://example.com/p");
    final Literal literal123 = rdf.createLiteral("123", Types.XSD_INTEGER);
    jena.add(graph, s, p, literal123);
    String out = jena.toString();
    assertEquals("<http://example.com/s> <http://example.com/p> \"123\"^^<http://www"
            + ".w3.org/2001/XMLSchema#integer> <http://example.com/> .\n", out);
    assertEquals(10L, dataset.size());
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new RDF4J();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new NativeStoreRDF();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new MemoryStoreRDF();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new MemoryGraphTest.MemoryStoreRDF();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new SimpleRDF();
}
 

import org.apache.commons.rdf.api.RDF; //导入依赖的package包/类
@Override
public RDF createFactory() {
    return new JsonLdRDF();
}