import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
/**
 * Read the state of the resource data at a particular point in time
 * @param directory the directory
 * @param identifier the identifier
 * @param time the time
 * @return the resource data, if it exists
 */
public static Optional<ResourceData> read(final File directory, final IRI identifier, final Instant time) {
    LOGGER.debug("Reading journal to generate the resource data");
    return of(new File(directory, RESOURCE_JOURNAL)).filter(File::exists).flatMap(file -> {
        final List<Instant> mementos = new ArrayList<>();
        final List<VersionRange> ranges = asTimeMap(file);
        ranges.stream().map(VersionRange::getFrom).findFirst().ifPresent(mementos::add);
        ranges.stream().map(VersionRange::getUntil).forEachOrdered(mementos::add);

        try (final Stream<Quad> stream = asStream(rdf, file, identifier, time)) {
            try (final Dataset dataset = stream.filter(isResourceTriple).collect(toDataset())) {
                LOGGER.debug("Creating resource: {} at {}", identifier, time);
                return from(identifier, dataset, mementos);
            } catch (final Exception ex) {
                throw new RuntimeRepositoryException("Error processing dataset", ex);
            }
        }
    });
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
private Stream<Authorization> getAllAuthorizationsFor(final Resource resource, final Boolean top) {
    LOGGER.debug("Checking ACL for: {}", resource.getIdentifier());
    final Optional<IRI> parent = resourceService.getContainer(resource.getIdentifier());
    if (resource.hasAcl()) {
        try (final Graph graph = resource.stream(Trellis.PreferAccessControl).collect(toGraph())) {
            final List<Authorization> authorizations = getAuthorizationFromGraph(graph);

            if (!top && authorizations.stream().anyMatch(getInheritedAuth(resource.getIdentifier()))) {
                return authorizations.stream().filter(getInheritedAuth(resource.getIdentifier()));
            }
            return authorizations.stream().filter(getAccessToAuth(resource.getIdentifier()));
        } catch (final Exception ex) {
            throw new RuntimeRepositoryException(ex);
        }
    }
    // Nothing here, check the parent
    LOGGER.debug("No ACL for {}; looking up parent resource", resource.getIdentifier());
    return parent.flatMap(resourceService::get).map(res -> getAllAuthorizationsFor(res, false))
        .orElseGet(Stream::empty);
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
/**
 * Create a binary service
 * @param idService the identifier service
 * @param partitions the identifier suppliers for each partition
 * @param resolvers the resolves
 */
public DefaultBinaryService(final IdentifierService idService, final Map<String, Properties> partitions,
        final List<BinaryService.Resolver> resolvers) {
    this.idService = idService;
    resolvers.forEach(resolver ->
            resolver.getUriSchemes().forEach(scheme ->
                this.resolvers.put(scheme, resolver)));
    partitions.forEach((k, v) -> {
        final String prefix = v.getProperty("prefix");
        if (isNull(prefix)) {
            throw new RuntimeRepositoryException("No prefix value defined for partition: " + k);
        }
        if (!this.resolvers.containsKey(prefix.split(":", 2)[0])) {
            throw new RuntimeRepositoryException("No binary resolver defined to handle prefix " +
                    prefix + " in partition " + k);
        }
        this.partitions.put(k, new IdentifierConfiguration(prefix,
                    parseInt(v.getProperty("levels", DEFAULT_LEVELS)),
                    parseInt(v.getProperty("length", DEFAULT_LENGTH))));
    });
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Override
public void write(final Stream<? extends Triple> triples, final OutputStream output, final RDFSyntax syntax,
        final IRI... profiles) {
    requireNonNull(triples, "The triples stream may not be null!");
    requireNonNull(output, "The output stream may not be null!");
    requireNonNull(syntax, "The RDF syntax value may not be null!");

    try {
        if (RDFA_HTML.equals(syntax)) {
            htmlSerializer.write(output, triples, profiles.length > 0 ? profiles[0] : null);
        } else {
            final Lang lang = rdf.asJenaLang(syntax).orElseThrow(() ->
                    new RuntimeRepositoryException("Invalid content type: " + syntax.mediaType));

            final RDFFormat format = defaultSerialization(lang);

            if (nonNull(format)) {
                LOGGER.debug("Writing stream-based RDF: {}", format);
                final StreamRDF stream = getWriterStream(output, format);
                stream.start();
                ofNullable(nsService).ifPresent(svc -> svc.getNamespaces().forEach(stream::prefix));
                triples.map(rdf::asJenaTriple).forEachOrdered(stream::triple);
                stream.finish();
            } else {
                LOGGER.debug("Writing buffered RDF: {}", lang);
                final org.apache.jena.graph.Graph graph = createDefaultGraph();
                ofNullable(nsService).map(NamespaceService::getNamespaces)
                    .ifPresent(graph.getPrefixMapping()::setNsPrefixes);
                triples.map(rdf::asJenaTriple).forEachOrdered(graph::add);
                if (JSONLD.equals(lang)) {
                    writeJsonLd(output, DatasetGraphFactory.create(graph), profiles);
                } else {
                    RDFDataMgr.write(output, graph, lang);
                }
            }
        }
    } catch (final AtlasException ex) {
        throw new RuntimeRepositoryException(ex);
    }
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Override
public Stream<? extends Triple> read(final InputStream input, final String base, final RDFSyntax syntax) {
    requireNonNull(input, "The input stream may not be null!");
    requireNonNull(syntax, "The syntax value may not be null!");

    try {
        final org.apache.jena.graph.Graph graph = createDefaultGraph();
        final Lang lang = rdf.asJenaLang(syntax).orElseThrow(() ->
                new RuntimeRepositoryException("Unsupported RDF Syntax: " + syntax.mediaType));

        RDFParser.source(input).lang(lang).base(base).parse(graph);

        // Check the graph for any new namespace definitions
        if (nonNull(nsService)) {
            final Set<String> namespaces = nsService.getNamespaces().entrySet().stream().map(Map.Entry::getValue)
                .collect(toSet());
            graph.getPrefixMapping().getNsPrefixMap().forEach((prefix, namespace) -> {
                if (!namespaces.contains(namespace)) {
                    LOGGER.debug("Setting prefix ({}) for namespace {}", prefix, namespace);
                    nsService.setPrefix(prefix, namespace);
                }
            });
        }
        return rdf.asGraph(graph).stream();
    } catch (final RiotException | AtlasException ex) {
        throw new RuntimeRepositoryException(ex);
    }
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testUpdateError() {
    final Graph graph = rdf.createGraph();
    getTriples().forEach(graph::add);
    assertEquals(3L, graph.size());
    assertThrows(RuntimeRepositoryException.class, () -> service.update(graph, "blah blah blah blah blah", null));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
private List<Authorization> getAuthorizationFromGraph(final Graph graph) {
    return graph.stream().map(Triple::getSubject).distinct().map(subject -> {
            try (final Graph subGraph = graph.stream(subject, null, null).collect(toGraph())) {
                return Authorization.from(subject, subGraph);
            } catch (final Exception ex) {
                throw new RuntimeRepositoryException("Error Processing graph", ex);
            }
        }).collect(toList());
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Override
public Supplier<String> getIdentifierSupplier(final String partition) {
    if (partitions.containsKey(partition)) {
        final IdentifierConfiguration config = partitions.get(partition);
        return idService.getSupplier(config.getPrefix(), config.getHierarchy(), config.getLength());
    }
    throw new RuntimeRepositoryException("Invalid partition: " + partition);
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testServiceNoPrefix() {
    final Properties props = new Properties();
    final Map<String, Properties> config = new HashMap<>();
    config.put("repository", props);

    assertThrows(RuntimeRepositoryException.class, () -> new DefaultBinaryService(mockIdService, config,
            asList(new FileResolver(emptyMap()))));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testServiceNoMatch() {
    final Properties props = new Properties();
    props.setProperty("prefix", "foo:");
    final Map<String, Properties> config = new HashMap<>();
    config.put("repository", props);

    assertThrows(RuntimeRepositoryException.class, () -> new DefaultBinaryService(mockIdService, config,
            asList(new FileResolver(emptyMap()))));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testUnknownPartition() {
    final Properties props = new Properties();
    props.setProperty("prefix", "file:");
    final Map<String, Properties> config = new HashMap<>();
    config.put("repository", props);

    final BinaryService service = new DefaultBinaryService(mockIdService, config,
            asList(new FileResolver(emptyMap())));

    assertThrows(RuntimeRepositoryException.class, () -> service.getIdentifierSupplier("nonexistent"));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testMalformedInput() {
    final ByteArrayInputStream in = new ByteArrayInputStream("<> <ex:test> a Literal\" . ".getBytes(UTF_8));
    assertThrows(RuntimeRepositoryException.class, () -> service.read(in, null, TURTLE));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testReadError() throws IOException {
    doThrow(new IOException()).when(mockInputStream).read(any(byte[].class), anyInt(), anyInt());
    assertThrows(RuntimeRepositoryException.class, () -> service.read(mockInputStream, "context", TURTLE));
}
 

import org.trellisldp.api.RuntimeRepositoryException; //导入依赖的package包/类
@Test
public void testWriteError() throws IOException {
    doThrow(new IOException()).when(mockOutputStream).write(any(byte[].class), anyInt(), anyInt());
    assertThrows(RuntimeRepositoryException.class, () -> service.write(getTriples(), mockOutputStream, TURTLE));
}