You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by st...@apache.org on 2018/02/15 01:55:00 UTC
[05/17] commons-rdf git commit: Split out fluent interfaces
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());
+ }
+}