http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/ParseJob.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/ParseJob.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParseJob.java new file mode 100644 index 0000000..eab29c9 --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParseJob.java @@ -0,0 +1,364 @@ +package org.apache.commons.rdf.simple.io; + +import java.util.AbstractMap.SimpleImmutableEntry; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.Optional; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.apache.commons.rdf.api.RDF; +import org.apache.commons.rdf.api.RDFSyntax; +import org.apache.commons.rdf.api.io.Option; +import org.apache.commons.rdf.api.io.ParserSource; +import org.apache.commons.rdf.api.io.ParserTarget; +import org.apache.commons.rdf.simple.SimpleRDF; + +@SuppressWarnings("rawtypes") +public interface ParseJob { + ParserImplementation impl(); + RDF rdf(); + ParserSource source(); + ParserTarget target(); + Optional<RDFSyntax> syntax(); + Stream<Map.Entry<Option, Object>> options(); + Map<Option, Object> optionsAsMap(); + ParseJob withRDF(RDF rdf); + ParseJob withSource(ParserSource p); + ParseJob withTarget(ParserTarget g); + ParseJob withSyntax(RDFSyntax s); + <O> ParseJob withOption(Option<O> o, O v); + ParseJob withImplementation(ParserImplementation impl); + ImmutableParseJob freeze(); +} + +interface ImmutableParseJob extends ParseJob { +} + +@SuppressWarnings("rawtypes") +final class MutableParseJob implements ParseJob, Cloneable { + private ParserImplementation impl; + private RDF rdf = new SimpleRDF(); + private ParserSource source; + private ParserTarget target; + private RDFSyntax syntax; + private Map<Option, Object> options = new LinkedHashMap<>(); + + @Override + public ParserImplementation impl() { + return Objects.requireNonNull(impl); + } + public ImmutableParseJob freeze() { + return new FrozenParseJob(this); + } + @Override + public RDF rdf() { + return Objects.requireNonNull(rdf); + } + @Override + public ParserSource source() { + return Objects.requireNonNull(source); + } + @Override + public ParserTarget target() { + return Objects.requireNonNull(target); + } + @Override + public Optional<RDFSyntax> syntax() { + return Optional.ofNullable(syntax); + } + @Override + public Stream<Entry<Option, Object>> options() { + return options.entrySet().stream(); + } + @Override + public Map<Option, Object> optionsAsMap() { + return Collections.unmodifiableMap(options); + } + @Override + public ParseJob withRDF(RDF rdf) { + this.rdf = rdf; + return this; + } + @Override + public ParseJob withSource(ParserSource s) { + this.source = s; + return this; + } + @Override + public ParseJob withTarget(ParserTarget t) { + this.target = t; + return this; + } + @Override + public ParseJob withSyntax(RDFSyntax s) { + this.syntax = s; + return this; + } + @Override + public <O> ParseJob withOption(Option<O> o, O v) { + options.put(o, v); + return this; + } + @Override + public ParseJob withImplementation(ParserImplementation impl) { + this.impl = impl; + return this; + } +} + + +@SuppressWarnings("rawtypes") +abstract class ImmutableParseJobImpl implements ImmutableParseJob { + @Override + public ParseJob withSource(ParserSource src) { + return new WithSource(src, this); + } + @Override + public ParseJob withSyntax(RDFSyntax s) { + return new WithSyntax(s, this); + } + @Override + public ParseJob withTarget(ParserTarget t) { + return new WithTarget(t, this); + } + public ParseJob withRDF(RDF rdf) { + return new WithRDF(rdf, this); + }; + public <O> ParseJob withOption(Option<O> o, O v) { + return new WithOption(o, v, this); + }; + @Override + public ParseJob withImplementation(ParserImplementation impl) { + return new WithImplementation(impl, this); + } + @Override + public ImmutableParseJob freeze() { + return this; + } +} + +@SuppressWarnings("rawtypes") +final class DefaultParseJob extends ImmutableParseJobImpl implements ImmutableParseJob { + @Override + public ParserSource source() { + throw new IllegalStateException("Source not set"); + } + @Override + public ParserTarget target() { + throw new IllegalStateException("Target not set"); + } + @Override + public Optional<RDFSyntax> syntax() { + return Optional.empty(); + } + @Override + public RDF rdf() { + return new SimpleRDF(); // fresh every time? + } + @Override + public Stream<Entry<Option, Object>> options() { + return Stream.empty(); + } + @Override + public Map<Option, Object> optionsAsMap() { + return Collections.emptyMap(); + } + @Override + public ParserImplementation impl() { + throw new IllegalStateException("Implementation not set"); + } +} + +@SuppressWarnings("rawtypes") +final class FrozenParseJob extends ImmutableParseJobImpl implements ImmutableParseJob { + private final ParserImplementation impl; + private final ParserSource source; + private final Optional<RDFSyntax> syntax; + private final ParserTarget target; + private final RDF rdf; + private final Map<Option, Object> options; + + public FrozenParseJob(ParseJob parseJob) { + this(parseJob.impl(), parseJob.source(), parseJob.syntax().orElse(null), + parseJob.target(), parseJob.rdf(), parseJob.optionsAsMap()); + } + public FrozenParseJob(ParserImplementation impl, ParserSource source, RDFSyntax syntax, ParserTarget target, RDF rdf, + Map<Option, Object> options) { + this.impl = Objects.requireNonNull(impl); + this.source = Objects.requireNonNull(source); + this.syntax = Optional.ofNullable(syntax); + this.target = Objects.requireNonNull(target); + this.rdf = Objects.requireNonNull(rdf); + // shallow copy of options + this.options = Collections.unmodifiableMap(new LinkedHashMap<>(options)); + } + @Override + public ParserImplementation impl() { + return impl; + } + @Override + public RDF rdf() { + return rdf; + } + @Override + public ParserSource source() { + return source; + } + @Override + public ParserTarget target() { + return target; + } + @Override + public Optional<RDFSyntax> syntax() { + return syntax; + } + @Override + public Stream<Entry<Option, Object>> options() { + return options.entrySet().stream(); + } + @Override + public Map<Option, Object> optionsAsMap() { + return options; + } +} + +@SuppressWarnings("rawtypes") +abstract class Inherited extends ImmutableParseJobImpl implements ImmutableParseJob { + private final ImmutableParseJob parent; + public Inherited() { + this(new DefaultParseJob()); + } + public Inherited(ImmutableParseJob job) { + parent = job; + } + @Override + public ParserSource source() { + return parent.source(); + } + @Override + public ParserTarget target() { + return parent.target(); + } + @Override + public Optional<RDFSyntax> syntax() { + return parent.syntax(); + } + @Override + public RDF rdf() { + return parent.rdf(); + } + @Override + public Stream<Entry<Option, Object>> options() { + return parent.options(); + } + @Override + public Map<Option, Object> optionsAsMap() { + return parent.optionsAsMap(); + } + @Override + public ParserImplementation impl() { + return parent.impl(); + } +} + +@SuppressWarnings("rawtypes") +final class WithSource extends Inherited { + private final ParserSource source; + + public WithSource(final ParserSource src) { + this.source = src; + } + public WithSource(final ParserSource src, final ImmutableParseJob parent) { + super(parent); + this.source = src; + } + @Override + public ParserSource source() { + return source; + } +} + +@SuppressWarnings("rawtypes") +final class WithTarget extends Inherited { + private final ParserTarget target; + + public WithTarget(final ParserTarget t) { + this.target = t; + } + public WithTarget(final ParserTarget t, final ImmutableParseJob parent) { + super(parent); + this.target = t; + } + @Override + public ParserTarget target() { + return target; + } +} + +final class WithSyntax extends Inherited { + private final RDFSyntax syntax; + public WithSyntax(final RDFSyntax s) { + syntax = s; + } + public WithSyntax(final RDFSyntax s, final ImmutableParseJob parent) { + super(parent); + syntax = s; + } + @Override + public Optional<RDFSyntax> syntax() { + return Optional.ofNullable(syntax); + } +} + +final class WithRDF extends Inherited { + private final RDF rdf; + public WithRDF(final RDF r) { + rdf = r; + } + public WithRDF(final RDF r, final ImmutableParseJob parent) { + super(parent); + rdf = r; + } + @Override + public RDF rdf() { + return rdf; + } +} + +@SuppressWarnings({ "rawtypes", "unchecked" }) +final class WithOption extends Inherited { + private Option<? extends Object> option; + private Object value; + public <O> WithOption(Option<O> o, O v, ImmutableParseJob parent) { + super(parent); + this.option = o; + this.value = v; + } + @Override + public Stream<Entry<Option, Object>> options() { + return Stream.concat(super.options(), Stream.of(new SimpleImmutableEntry(option, value))); + } + @Override + public Map<Option, Object> optionsAsMap() { + return options().collect(Collectors.toMap(Entry::getKey, Entry::getValue)); + } +} + +final class WithImplementation extends Inherited { + private final ParserImplementation impl; + public WithImplementation(ParserImplementation impl) { + this.impl = impl; + } + public WithImplementation(ParserImplementation impl, ImmutableParseJob parent) { + super(parent); + this.impl = impl; + } + @Override + public ParserImplementation impl() { + return impl; + } +}
http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/ParsedImpl.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/ParsedImpl.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParsedImpl.java new file mode 100644 index 0000000..3beed15 --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParsedImpl.java @@ -0,0 +1,34 @@ +package org.apache.commons.rdf.simple.io; + +import org.apache.commons.rdf.api.io.Parsed; +import org.apache.commons.rdf.api.io.ParserSource; +import org.apache.commons.rdf.api.io.ParserTarget; + +public class ParsedImpl<T,S> implements Parsed<T, S> { + + private final ParserSource<S> source; + private final ParserTarget<T> target; + private final long count; + + public ParsedImpl(ParserSource<S> source, ParserTarget<T> target, final long count) { + this.source = source; + this.target = target; + this.count = count; + } + + @Override + public long count() { + return count; + } + + @Override + public ParserSource<S> source() { + return source; + } + + @Override + public ParserTarget<T> target() { + return target; + } + +} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserBuilder.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserBuilder.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserBuilder.java new file mode 100644 index 0000000..bb3eec7 --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserBuilder.java @@ -0,0 +1,159 @@ +package org.apache.commons.rdf.simple.io; + +import java.io.InputStream; +import java.nio.file.Path; +import java.util.Map; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.Future; + +import org.apache.commons.rdf.api.Dataset; +import org.apache.commons.rdf.api.Graph; +import org.apache.commons.rdf.api.IRI; +import org.apache.commons.rdf.api.RDF; +import org.apache.commons.rdf.api.RDFSyntax; +import org.apache.commons.rdf.api.io.Async; +import org.apache.commons.rdf.api.io.NeedSourceBased; +import org.apache.commons.rdf.api.io.NeedSourceOrBase; +import org.apache.commons.rdf.api.io.NeedTargetOrRDF; +import org.apache.commons.rdf.api.io.Option; +import org.apache.commons.rdf.api.io.OptionalTarget; +import org.apache.commons.rdf.api.io.Parsed; +import org.apache.commons.rdf.api.io.ParserSource; +import org.apache.commons.rdf.api.io.ParserTarget; +import org.apache.commons.rdf.api.io.Sync; +import org.apache.commons.rdf.api.io.Option.RequiredOption; + +@SuppressWarnings({ "rawtypes", "unchecked" }) +public final class ParserBuilder implements NeedTargetOrRDF, NeedSourceBased, Sync, NeedSourceOrBase, OptionalTarget, + Async { + + public static enum AsyncOption implements RequiredOption<ExecutorService> { + EXECUTOR_SERVICE + } + + public static enum BaseOption implements RequiredOption<IRI> { + BASE + } + + private final ParseJob parseJob; + + public ParserBuilder() { + this.parseJob = new DefaultParseJob(); + } + + public ParserBuilder(ParserImplementation impl) { + this.parseJob = new WithImplementation(impl); + } + + public ParserBuilder(ParseJob parseJob) { + this.parseJob = parseJob; + } + + @Override + public Async async() { + return async(ForkJoinPool.commonPool()); + } + + @Override + public Async async(ExecutorService executor) { + return newState(parseJob.withOption(AsyncOption.EXECUTOR_SERVICE, executor)); + } + + @Override + public NeedSourceBased<Dataset> base(IRI iri) { + return newState(implicitTarget().withOption(BaseOption.BASE, iri)); + } + + @Override + public NeedSourceBased<Dataset> base(String iri) { + return base(parseJob.rdf().createIRI(iri)); + } + + @Override + public ParserBuilder build() { + return newState(parseJob.freeze()); + } + + @Override + public ParserBuilder option(Option o, Object v) { + return newState(parseJob.withOption(o, v)); + } + + @Override + public Parsed parse() { + ParserImplementation impl = parseJob.impl(); + long count = impl.parse(parseJob.source(), parseJob.syntax().orElse(null), parseJob.target(), parseJob.rdf(), parseJob.optionsAsMap()); + return new ParsedImpl<>(parseJob.source(), parseJob.target(), count); + } + + @Override + public Future parseAsync() { + Map<Option, Object> options = parseJob.optionsAsMap(); + ExecutorService executor = (ExecutorService) options.getOrDefault(AsyncOption.EXECUTOR_SERVICE, + ForkJoinPool.commonPool()); + return executor.submit(this::parse); + } + + @Override + public OptionalTarget rdf(RDF rdf) { + return newState(parseJob.withRDF(rdf)); + } + + @Override + public Sync source(InputStream is) { + return source(new InputStreamSource(is)); + } + + @Override + public Sync source(IRI iri) { + return source(new IRISource(iri)); + } + + @Override + public Sync source(Path path) { + return source(new PathSource(path)); + } + + @Override + public Sync source(ParserSource source) { + return newState(implicitTarget().withSource(source)); + } + + @Override + public Sync source(String iri) { + return source(parseJob.rdf().createIRI(iri)); + } + + public NeedSourceOrBase syntax(RDFSyntax syntax) { + return newState(parseJob.withSyntax(syntax)); + } + + @Override + public NeedSourceOrBase<Dataset> target(Dataset dataset) { + return target(new DatasetTarget(dataset)); + } + + @Override + public NeedSourceOrBase<Graph> target(Graph graph) { + return target(new GraphTarget(graph)); + } + + @Override + public NeedSourceOrBase target(ParserTarget target) { + return newState(parseJob.withTarget(target)); + } + + private ParseJob implicitTarget() { + return parseJob.withTarget(new ImplicitDatasetTarget(parseJob.rdf())); + } + + private ParserBuilder newState(ParseJob newState) { + if (this.parseJob == newState) { + // probably a MutableParseJob + return this; + } + return new ParserBuilder(newState); + } + +} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserFactoryImpl.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserFactoryImpl.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserFactoryImpl.java new file mode 100644 index 0000000..e5df228 --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserFactoryImpl.java @@ -0,0 +1,52 @@ +package org.apache.commons.rdf.simple.io; + +import org.apache.commons.rdf.api.Dataset; +import org.apache.commons.rdf.api.Graph; +import org.apache.commons.rdf.api.RDF; +import org.apache.commons.rdf.api.RDFSyntax; +import org.apache.commons.rdf.api.io.NeedSourceOrBase; +import org.apache.commons.rdf.api.io.NeedTargetOrRDF; +import org.apache.commons.rdf.api.io.OptionalTarget; +import org.apache.commons.rdf.api.io.ParserFactory; +import org.apache.commons.rdf.api.io.ParserTarget; + +public class ParserFactoryImpl implements ParserFactory { + + private ParserImplementation impl; + + public ParserFactoryImpl(ParserImplementation impl) { + this.impl = impl; + } + + @Override + public NeedSourceOrBase<Graph> target(Graph graph) { + return target(new GraphTarget(graph)); + } + + @Override + public NeedSourceOrBase<Dataset> target(Dataset dataset) { + return target(new DatasetTarget(dataset)); + } + + @SuppressWarnings("unchecked") + @Override + public <T> NeedSourceOrBase<T> target(ParserTarget<T> target) { + return new ParserBuilder(mutableState().withTarget(target)); + } + + @SuppressWarnings("unchecked") + @Override + public OptionalTarget<Dataset> rdf(RDF rdf) { + return new ParserBuilder(mutableState().withRDF(rdf)); + } + + private ParseJob mutableState() { + return new MutableParseJob().withImplementation(impl); + } + + @Override + public NeedTargetOrRDF syntax(RDFSyntax syntax) { + return new ParserBuilder(mutableState().withSyntax(syntax)); + } + +} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserImplementation.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserImplementation.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserImplementation.java new file mode 100644 index 0000000..6199314 --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/ParserImplementation.java @@ -0,0 +1,14 @@ +package org.apache.commons.rdf.simple.io; + +import java.util.Map; + +import org.apache.commons.rdf.api.RDF; +import org.apache.commons.rdf.api.RDFSyntax; +import org.apache.commons.rdf.api.io.Option; +import org.apache.commons.rdf.api.io.ParserSource; +import org.apache.commons.rdf.api.io.ParserTarget; + +public interface ParserImplementation { + @SuppressWarnings("rawtypes") + public long parse(ParserSource source, RDFSyntax rdfSyntax, ParserTarget target, RDF rdf, Map<Option, Object> options); +} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/PathSource.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/PathSource.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/PathSource.java new file mode 100644 index 0000000..25fdd0a --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/PathSource.java @@ -0,0 +1,46 @@ +package org.apache.commons.rdf.simple.io; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Optional; + +import org.apache.commons.rdf.api.IRI; +import org.apache.commons.rdf.api.RDF; +import org.apache.commons.rdf.api.io.ParserSource; +import org.apache.commons.rdf.simple.SimpleRDF; + +public class PathSource implements ParserSource<Path> { + private final Path source; + + private static final RDF rdf = new SimpleRDF(); + + public PathSource(Path source) { + this.source = source; + } + + @Override + public Path source() { + return source; + } + + @Override + public InputStream inputStream() throws IOException { + return Files.newInputStream(source); + } + + @Override + public Optional<IRI> iri() { + Path p; + try { + // Resolve any symlinks etc. + p = source.toRealPath(); + } catch (IOException e) { + // Probably some folder is not found, use full path as-is + p = source.toAbsolutePath(); + } + return Optional.of(rdf.createIRI(p.toUri().toString())); + } + +} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/main/java/org/apache/commons/rdf/simple/io/package-info.java ---------------------------------------------------------------------- diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/io/package-info.java b/simple/src/main/java/org/apache/commons/rdf/simple/io/package-info.java new file mode 100644 index 0000000..c80524e --- /dev/null +++ b/simple/src/main/java/org/apache/commons/rdf/simple/io/package-info.java @@ -0,0 +1,21 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * + */ +package org.apache.commons.rdf.simple.io; \ No newline at end of file http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/test/java/org/apache/commons/rdf/simple/experimental/ParserFactoryTest.java ---------------------------------------------------------------------- diff --git a/simple/src/test/java/org/apache/commons/rdf/simple/experimental/ParserFactoryTest.java b/simple/src/test/java/org/apache/commons/rdf/simple/experimental/ParserFactoryTest.java deleted file mode 100644 index a5b63c2..0000000 --- a/simple/src/test/java/org/apache/commons/rdf/simple/experimental/ParserFactoryTest.java +++ /dev/null @@ -1,24 +0,0 @@ -package org.apache.commons.rdf.simple.experimental; - -import static org.junit.Assert.*; - -import java.io.InputStream; -import java.util.concurrent.Future; - -import org.apache.commons.rdf.api.RDFSyntax; -import org.apache.commons.rdf.experimental.ParserFactory; -import org.apache.commons.rdf.experimental.ParserFactory.*; -import org.apache.commons.rdf.simple.SimpleRDF; -import org.junit.Test; - -public class ParserFactoryTest { - @Test - public void testName() throws Exception { - ParserFactory f = new ParserFactoryImpl((a,b,c,d,e) -> 1); - InputStream is = getClass().getResourceAsStream("Fred"); - Async g = f.syntax(RDFSyntax.JSONLD).rdf(new SimpleRDF()).base("http://example.com/";).source(is).async(); - Future<Parsed<?,?>> x = g.parseAsync(); - Parsed<?, ?> p = x.get(); - System.out.println(p.count()); - } -} http://git-wip-us.apache.org/repos/asf/commons-rdf/blob/a11db68d/simple/src/test/java/org/apache/commons/rdf/simple/io/ParserFactoryTest.java ---------------------------------------------------------------------- diff --git a/simple/src/test/java/org/apache/commons/rdf/simple/io/ParserFactoryTest.java b/simple/src/test/java/org/apache/commons/rdf/simple/io/ParserFactoryTest.java new file mode 100644 index 0000000..1377c2f --- /dev/null +++ b/simple/src/test/java/org/apache/commons/rdf/simple/io/ParserFactoryTest.java @@ -0,0 +1,30 @@ +package org.apache.commons.rdf.simple.io; + +import java.io.InputStream; +import java.util.concurrent.Future; + +import org.apache.commons.rdf.api.Dataset; +import org.apache.commons.rdf.api.RDFSyntax; +import org.apache.commons.rdf.api.io.Async; +import org.apache.commons.rdf.api.io.OptionalTarget; +import org.apache.commons.rdf.api.io.Parsed; +import org.apache.commons.rdf.api.io.ParserFactory; +import org.apache.commons.rdf.simple.SimpleRDF; +import org.junit.Test; + +public class ParserFactoryTest { + @Test + public void testName() throws Exception { + ParserFactory f = new ParserFactoryImpl((a,b,c,d,e) -> 1); + InputStream is = getClass().getResourceAsStream("Fred"); + OptionalTarget<Dataset> p = f.rdf(new SimpleRDF()); + Dataset ds = p.source("hello").parse().target().target(); + + + Async<Dataset, InputStream> g = f.syntax(RDFSyntax.JSONLD).rdf(new SimpleRDF()).base("http://example.com/";).source(is).async(); + + Future<Parsed<Dataset, InputStream>> x = g.parseAsync(); + Parsed<Dataset, InputStream> p2 = x.get(); + System.out.println(p2.count()); + } +}
