AbstractRDFParser (Commons RDF 0.6.0-SNAPSHOT API)

java.lang.Object
- org.apache.commons.rdf.simple.experimental.AbstractRDFParser<T>

All Implemented Interfaces:

Cloneable, RDFParser

Direct Known Subclasses:

JenaRDFParser, JsonLdParser, RDF4JParser
```
public abstract class AbstractRDFParser<T extends AbstractRDFParser<T>>
extends Object
implements RDFParser, Cloneable
```
Abstract RDFParser
This abstract class keeps the properties in protected fields like sourceFile using Optional. Some basic checking like checkIsAbsolute(IRI) is performed.
This class and its subclasses are Cloneable, immutable and (therefore) thread-safe - each call to option methods like contentType(String) or source(IRI) will return a cloned, mutated copy.
By default, parsing is done by the abstract method parseSynchronusly() - which is executed in a cloned snapshot - hence multiple parse() calls are thread-safe. The default parse() uses a thread pool in threadGroup - but implementations can override parse() (e.g. because it has its own threading model or use asynchronous remote execution).

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.commons.rdf.experimental.RDFParser
  RDFParser.ParseResult

Field Summary

Fields
Modifier and Type Field and Description

static ThreadGroup threadGroup

Fields
Modifier and Type	Field and Description
`static ThreadGroup`	`threadGroup`

Constructor Summary

Constructors
Constructor and Description

AbstractRDFParser()

Constructors
Constructor and Description
`AbstractRDFParser()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected T`	`asT()`
`T`	`base(IRI base)` Specify a base IRI to use for parsing any relative IRI references.
`T`	`base(String base)` Specify a base IRI to use for parsing any relative IRI references.
`protected void`	`checkBaseRequired()` Check if base is required.
`protected void`	`checkContentType()` Subclasses can override this method to check compatibility with the contentType setting.
`protected void`	`checkIsAbsolute(IRI iri)` Check if an iri is absolute.
`protected void`	`checkSource()` Check that one and only one source is present and valid.
`protected void`	`checkTarget()` Subclasses can override this method to check the target is valid.
`T`	`clone()`
`T`	`contentType(RDFSyntax rdfSyntax)` Specify the content type of the RDF syntax to parse.
`T`	`contentType(String contentType)` Specify the content type of the RDF syntax to parse.
`protected RDF`	`createRDFTermFactory()` Create a new `RDF` for a parse session.
`Optional<IRI>`	`getBase()` Get the set base `IRI`, if present.
`Optional<String>`	`getContentType()` Get the set content-type String, if any.
`Optional<RDFSyntax>`	`getContentTypeSyntax()` Get the set content-type `RDFSyntax`, if any.
`Optional<RDF>`	`getRdfTermFactory()` Get the set `RDF`, if any.
`Optional<Path>`	`getSourceFile()` Get the set source `Path`.
`Optional<InputStream>`	`getSourceInputStream()` Get the set source `InputStream`.
`Optional<IRI>`	`getSourceIri()` Get the set source `Path`.
`Consumer<Quad>`	`getTarget()` Get the target to consume parsed Quads.
`Optional<Dataset>`	`getTargetDataset()` Get the target dataset as set by `target(Dataset)`.
`Optional<Graph>`	`getTargetGraph()` Get the target graph as set by `target(Graph)`.
`protected static Optional<RDFSyntax>`	`guessRDFSyntax(Path path)` Guess RDFSyntax from a local file's extension.
`Future<RDFParser.ParseResult>`	`parse()` Parse the specified source.
`protected abstract void`	`parseSynchronusly()` Parse `sourceInputStream`, `sourceFile` or `sourceIri`.
`protected T`	`prepareForParsing()` Prepare a clone of this RDFParser which have been checked and completed.
`T`	`rdfTermFactory(RDF rdfTermFactory)` Specify which `RDF` to use for generating `RDFTerm`s.
`protected void`	`resetSource()` Reset all source* fields to Optional.empty()
`protected void`	`resetTarget()` Reset all optional target* fields to `Optional.empty()`.
`T`	`source(InputStream inputStream)` Specify a source `InputStream` to parse.
`T`	`source(IRI iri)` Specify an absolute source `IRI` to retrieve and parse.
`T`	`source(Path file)` Specify a source file `Path` to parse.
`T`	`source(String iri)` Specify an absolute source IRI to retrieve and parse.
`T`	`target(Consumer<Quad> consumer)` Specify a consumer for parsed quads.
`T`	`target(Dataset dataset)` Specify a `Dataset` to add parsed quads to.
`T`	`target(Graph graph)` Specify a `Graph` to add parsed triples to.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - threadGroup
```
public static final ThreadGroup threadGroup
```
- Constructor Detail
  - AbstractRDFParser
```
public AbstractRDFParser()
```
- Method Detail
  - getRdfTermFactory
```
public Optional<RDF> getRdfTermFactory()
```
    Get the set RDF, if any.
    
    Returns:
    
    The RDF to use, or Optional.empty() if it has not been set
  - getContentTypeSyntax
```
public Optional<RDFSyntax> getContentTypeSyntax()
```
    Get the set content-type RDFSyntax, if any.
    If this is Optional.isPresent(), then getContentType() contains the value of RDFSyntax.mediaType().
    
    Returns:
    
    The RDFSyntax of the content type, or Optional.empty() if it has not been set
  - getContentType
```
public final Optional<String> getContentType()
```
    Get the set content-type String, if any.
    If this is Optional.isPresent() and is recognized by RDFSyntax.byMediaType(String), then the corresponding RDFSyntax is set on getContentType(), otherwise that is Optional.empty().
    
    Returns:
    
    The Content-Type IANA media type, e.g. text/turtle, or Optional.empty() if it has not been set
  - getTarget
```
public Consumer<Quad> getTarget()
```
    Get the target to consume parsed Quads.
    From the call to parseSynchronusly(), this will be a non-null value (as a target is a required setting).
    
    Returns:
    
    The target consumer of Quads, or null if it has not yet been set.
  - getTargetDataset
```
public Optional<Dataset> getTargetDataset()
```
    Get the target dataset as set by target(Dataset).
    The return value is Optional.isPresent() if and only if target(Dataset) has been set, meaning that the implementation may choose to append parsed quads to the Dataset directly instead of relying on the generated getTarget() consumer.
    If this value is present, then getTargetGraph() MUST be Optional.empty().
    
    Returns:
    
    The target Dataset, or Optional.empty() if another kind of target has been set.
  - getTargetGraph
```
public Optional<Graph> getTargetGraph()
```
    Get the target graph as set by target(Graph).
    The return value is Optional.isPresent() if and only if target(Graph) has been set, meaning that the implementation may choose to append parsed triples to the Graph directly instead of relying on the generated getTarget() consumer.
    If this value is present, then getTargetDataset() MUST be Optional.empty().
    
    Returns:
    
    The target Graph, or Optional.empty() if another kind of target has been set.
  - getBase
```
public Optional<IRI> getBase()
```
    Get the set base IRI, if present.
    
    Returns:
    
    The base IRI, or Optional.empty() if it has not been set
  - getSourceInputStream
```
public Optional<InputStream> getSourceInputStream()
```
    Get the set source InputStream.
    If this is Optional.isPresent(), then getSourceFile() and getSourceIri() are Optional.empty().
    
    Returns:
    
    The source InputStream, or Optional.empty() if it has not been set
  - getSourceFile
```
public Optional<Path> getSourceFile()
```
    Get the set source Path.
    If this is Optional.isPresent(), then getSourceInputStream() and getSourceIri() are Optional.empty().
    
    Returns:
    
    The source Path, or Optional.empty() if it has not been set
  - getSourceIri
```
public Optional<IRI> getSourceIri()
```
    Get the set source Path.
    If this is Optional.isPresent(), then getSourceInputStream() and getSourceInputStream() are Optional.empty().
    
    Returns:
    
    The source IRI, or Optional.empty() if it has not been set
  - clone
```
public T clone()
```
    Overrides:
    
    clone in class Object
  - asT
```
protected T asT()
```
  - rdfTermFactory
```
public T rdfTermFactory(RDF rdfTermFactory)
```
    Description copied from interface: RDFParser
    
    Specify which RDF to use for generating RDFTerms.
    This option may be used together with RDFParser.target(Graph) to override the implementation's default factory and graph.
    Warning: Using the same RDF for multiple RDFParser.parse() calls may accidentally merge BlankNodes having the same label, as the parser may use the RDF.createBlankNode(String) method from the parsed blank node labels.
    
    Specified by:
    
    rdfTermFactory in interface RDFParser
    
    Parameters:
    
    rdfTermFactory - RDF to use for generating RDFTerms.
    
    Returns:
    
    An RDFParser that will use the specified rdfTermFactory
    
    See Also:
    
    RDFParser.target(Graph)
  - contentType
```
public T contentType(RDFSyntax rdfSyntax)
              throws IllegalArgumentException
```
    Description copied from interface: RDFParser
    
    Specify the content type of the RDF syntax to parse.
    This option can be used to select the RDFSyntax of the source, overriding any Content-Type headers or equivalent.
    The character set of the RDFSyntax is assumed to be StandardCharsets.UTF_8 unless overridden within the document (e.g. <?xml version="1.0" encoding="iso-8859-1"?> in RDFSyntax.RDFXML).
    This method will override any contentType set with RDFParser.contentType(String).
    
    Specified by:
    
    contentType in interface RDFParser
    
    Parameters:
    
    rdfSyntax - An RDFSyntax to parse the source according to, e.g. RDFSyntax.TURTLE.
    
    Returns:
    
    An RDFParser that will use the specified content type.
    
    Throws:
    
    IllegalArgumentException - If this RDFParser does not support the specified RDFSyntax.
    
    See Also:
    
    RDFParser.contentType(String)
  - contentType
```
public T contentType(String contentType)
              throws IllegalArgumentException
```
    Description copied from interface: RDFParser
    
    Specify the content type of the RDF syntax to parse.
    This option can be used to select the RDFSyntax of the source, overriding any Content-Type headers or equivalent.
    The content type MAY include a charset parameter if the RDF media types permit it; the default charset is StandardCharsets.UTF_8 unless overridden within the document.
    This method will override any contentType set with RDFParser.contentType(RDFSyntax).
    
    Specified by:
    
    contentType in interface RDFParser
    
    Parameters:
    
    contentType - A content-type string, e.g. application/ld+json or text/turtle;charset="UTF-8" as specified by RFC7231.
    
    Returns:
    
    An RDFParser that will use the specified content type.
    
    Throws:
    
    IllegalArgumentException - If the contentType has an invalid syntax, or this RDFParser does not support the specified contentType.
    
    See Also:
    
    RDFParser.contentType(RDFSyntax)
  - base
```
public T base(IRI base)
```
    Description copied from interface: RDFParser
    
    Specify a base IRI to use for parsing any relative IRI references.
    Setting this option will override any protocol-specific base IRI (e.g. Content-Location header) or the RDFParser.source(IRI) IRI, but does not override any base IRIs set within the source document (e.g. @base in Turtle documents).
    If the source is in a syntax that does not support relative IRI references (e.g. RDFSyntax.NTRIPLES), setting the base has no effect.
    This method will override any base IRI set with RDFParser.base(String).
    
    Specified by:
    
    base in interface RDFParser
    
    Parameters:
    
    base - An absolute IRI to use as a base.
    
    Returns:
    
    An RDFParser that will use the specified base IRI.
    
    See Also:
    
    RDFParser.base(String)
  - base
```
public T base(String base)
       throws IllegalArgumentException
```
    Description copied from interface: RDFParser
    
    Specify a base IRI to use for parsing any relative IRI references.
    Setting this option will override any protocol-specific base IRI (e.g. Content-Location header) or the RDFParser.source(IRI) IRI, but does not override any base IRIs set within the source document (e.g. @base in Turtle documents).
    If the source is in a syntax that does not support relative IRI references (e.g. RDFSyntax.NTRIPLES), setting the base has no effect.
    This method will override any base IRI set with RDFParser.base(IRI).
    
    Specified by:
    
    base in interface RDFParser
    
    Parameters:
    
    base - An absolute IRI to use as a base.
    
    Returns:
    
    An RDFParser that will use the specified base IRI.
    
    Throws:
    
    IllegalArgumentException - If the base is not a valid absolute IRI string
    
    See Also:
    
    RDFParser.base(IRI)
  - source
```
public T source(InputStream inputStream)
```
    Description copied from interface: RDFParser
    
    Specify a source InputStream to parse.
    The source set will not be read before the call to RDFParser.parse().
    The InputStream will not be closed after parsing. The InputStream does not need to support InputStream.markSupported().
    The parser might not consume the complete stream (e.g. an RDF/XML parser may not read beyond the closing tag of </rdf:Description>).
    The RDFParser.contentType(RDFSyntax) or RDFParser.contentType(String) SHOULD be set before calling RDFParser.parse().
    The character set is assumed to be StandardCharsets.UTF_8 unless the RDFParser.contentType(String) specifies otherwise or the document declares its own charset (e.g. RDF/XML with a <?xml encoding="iso-8859-1"> header).
    The RDFParser.base(IRI) or RDFParser.base(String) MUST be set before calling RDFParser.parse(), unless the RDF syntax does not permit relative IRIs (e.g. RDFSyntax.NTRIPLES).
    This method will override any source set with RDFParser.source(IRI), RDFParser.source(Path) or RDFParser.source(String).
    
    Specified by:
    
    source in interface RDFParser
    
    Parameters:
    
    inputStream - An InputStream to consume
    
    Returns:
    
    An RDFParser that will use the specified source.
  - source
```
public T source(Path file)
```
    Description copied from interface: RDFParser
    
    Specify a source file Path to parse.
    The source set will not be read before the call to RDFParser.parse().
    The RDFParser.contentType(RDFSyntax) or RDFParser.contentType(String) SHOULD be set before calling RDFParser.parse().
    The character set is assumed to be StandardCharsets.UTF_8 unless the RDFParser.contentType(String) specifies otherwise or the document declares its own charset (e.g. RDF/XML with a <?xml encoding="iso-8859-1"> header).
    The RDFParser.base(IRI) or RDFParser.base(String) MAY be set before calling RDFParser.parse(), otherwise Path.toUri() will be used as the base IRI.
    This method will override any source set with RDFParser.source(IRI), RDFParser.source(InputStream) or RDFParser.source(String).
    
    Specified by:
    
    source in interface RDFParser
    
    Parameters:
    
    file - A Path for a file to parse
    
    Returns:
    
    An RDFParser that will use the specified source.
  - source
```
public T source(IRI iri)
```
    Description copied from interface: RDFParser
    
    Specify an absolute source IRI to retrieve and parse.
    The source set will not be read before the call to RDFParser.parse().
    If this builder does not support the given IRI protocol (e.g. urn:uuid:ce667463-c5ab-4c23-9b64-701d055c4890), this method should succeed, while the RDFParser.parse() should throw an IOException.
    The RDFParser.contentType(RDFSyntax) or RDFParser.contentType(String) MAY be set before calling RDFParser.parse(), in which case that type MAY be used for content negotiation (e.g. Accept header in HTTP), and SHOULD be used for selecting the RDFSyntax.
    The character set is assumed to be StandardCharsets.UTF_8 unless the protocol's equivalent of Content-Type specifies otherwise or the document declares its own charset (e.g. RDF/XML with a <?xml encoding="iso-8859-1"> header).
    The RDFParser.base(IRI) or RDFParser.base(String) MAY be set before calling RDFParser.parse(), otherwise the source IRI will be used as the base IRI.
    This method will override any source set with RDFParser.source(Path), RDFParser.source(InputStream) or RDFParser.source(String).
    
    Specified by:
    
    source in interface RDFParser
    
    Parameters:
    
    iri - An IRI to retrieve and parse
    
    Returns:
    
    An RDFParser that will use the specified source.
  - source
```
public T source(String iri)
         throws IllegalArgumentException
```
    Description copied from interface: RDFParser
    
    Specify an absolute source IRI to retrieve and parse.
    The source set will not be read before the call to RDFParser.parse().
    If this builder does not support the given IRI (e.g. urn:uuid:ce667463-c5ab-4c23-9b64-701d055c4890), this method should succeed, while the RDFParser.parse() should throw an IOException.
    The RDFParser.contentType(RDFSyntax) or RDFParser.contentType(String) MAY be set before calling RDFParser.parse(), in which case that type MAY be used for content negotiation (e.g. Accept header in HTTP), and SHOULD be used for selecting the RDFSyntax.
    The character set is assumed to be StandardCharsets.UTF_8 unless the protocol's equivalent of Content-Type specifies otherwise or the document declares its own charset (e.g. RDF/XML with a <?xml encoding="iso-8859-1"> header).
    The RDFParser.base(IRI) or RDFParser.base(String) MAY be set before calling RDFParser.parse(), otherwise the source IRI will be used as the base IRI.
    This method will override any source set with RDFParser.source(Path), RDFParser.source(InputStream) or RDFParser.source(IRI).
    
    Specified by:
    
    source in interface RDFParser
    
    Parameters:
    
    iri - An IRI to retrieve and parse
    
    Returns:
    
    An RDFParser that will use the specified source.
    
    Throws:
    
    IllegalArgumentException - If the base is not a valid absolute IRI string
  - checkIsAbsolute
```
protected void checkIsAbsolute(IRI iri)
                        throws IllegalArgumentException
```
    Check if an iri is absolute.
    Used by source(String) and base(String).
    
    Parameters:
    
    iri - IRI to check
    
    Throws:
    
    IllegalArgumentException - If the IRI is not absolute
  - checkSource
```
protected void checkSource()
                    throws IOException
```
    Check that one and only one source is present and valid.
    Used by parse().
    Subclasses might override this method, e.g. to support other source combinations, or to check if the sourceIri is resolvable.
    
    Throws:
    
    IOException - If a source file can't be read
  - checkBaseRequired
```
protected void checkBaseRequired()
                          throws IllegalStateException
```
    Check if base is required.
    
    Throws:
    
    IllegalStateException - if base is required, but not set.
  - resetSource
```
protected void resetSource()
```
    Reset all source* fields to Optional.empty()
    Subclasses should override this and call super.resetSource() if they need to reset any additional source* fields.
  - resetTarget
```
protected void resetTarget()
```
    Reset all optional target* fields to Optional.empty().
    Note that the consumer set for getTarget() is note reset.
    Subclasses should override this and call super.resetTarget() if they need to reset any additional target* fields.
  - parseSynchronusly
```
protected abstract void parseSynchronusly()
                                   throws IOException,
                                          RDFParseException
```
    Parse sourceInputStream, sourceFile or sourceIri.
    One of the source fields MUST be present, as checked by checkSource().
    checkBaseRequired() is called to verify if getBase() is required.
    
    Throws:
    
    IOException - If the source could not be read
    
    RDFParseException - If the source could not be parsed (e.g. a .ttl file was not valid Turtle)
  - prepareForParsing
```
protected T prepareForParsing()
                       throws IOException,
                              IllegalStateException
```
    Prepare a clone of this RDFParser which have been checked and completed.
    The returned clone will always have getTarget() and getRdfTermFactory() present.
    If the getSourceFile() is present, but the getBase() is not present, the base will be set to the file:/// IRI for the Path's real path (e.g. resolving any symbolic links).
    
    Returns:
    
    A completed and checked clone of this RDFParser
    
    Throws:
    
    IOException - If the source was not accessible (e.g. a file was not found)
    
    IllegalStateException - If the parser was not in a compatible setting (e.g. contentType was an invalid string)
  - checkTarget
```
protected void checkTarget()
```
    Subclasses can override this method to check the target is valid.
    The default implementation throws an IllegalStateException if the target has not been set.
  - checkContentType
```
protected void checkContentType()
                         throws IllegalStateException
```
    Subclasses can override this method to check compatibility with the contentType setting.
    
    Throws:
    
    IllegalStateException - if the getContentType() or getContentTypeSyntax() is not compatible or invalid
  - guessRDFSyntax
```
protected static Optional<RDFSyntax> guessRDFSyntax(Path path)
```
    Guess RDFSyntax from a local file's extension.
    This method can be used by subclasses if getContentType() is not present and getSourceFile() is set.
    
    Parameters:
    
    path - Path which extension should be checked
    
    Returns:
    
    The RDFSyntax which has a matching RDFSyntax.fileExtension(), otherwise Optional.empty().
  - createRDFTermFactory
```
protected RDF createRDFTermFactory()
```
    Create a new RDF for a parse session.
    This is called by parse() to set rdfTermFactory(RDF) if it is Optional.empty().
    As parsed blank nodes might be made with RDF.createBlankNode(String), each call to this method SHOULD return a new RDF instance.
    
    Returns:
    
    A new RDF
  - parse
```
public Future<RDFParser.ParseResult> parse()
                                    throws IOException,
                                           IllegalStateException
```
    Description copied from interface: RDFParser
    
    Parse the specified source.
    A source method (e.g. RDFParser.source(InputStream), RDFParser.source(IRI), RDFParser.source(Path), RDFParser.source(String) or an equivalent subclass method) MUST have been called before calling this method, otherwise an IllegalStateException will be thrown.
    A target method (e.g. RDFParser.target(Consumer), RDFParser.target(Dataset), RDFParser.target(Graph) or an equivalent subclass method) MUST have been called before calling parse(), otherwise an IllegalStateException will be thrown.
    It is undefined if this method is thread-safe, however the RDFParser may be reused (e.g. setting a different source) as soon as the Future has been returned from this method.
    The RDFParser SHOULD perform the parsing as an asynchronous operation, and return the Future as soon as preliminary checks (such as validity of the RDFParser.source(IRI) and RDFParser.contentType(RDFSyntax) settings) have finished. The future SHOULD not mark Future.isDone() before parsing is complete. A synchronous implementation MAY be blocking on the parse() call and return a Future that is already Future.isDone().
    The returned Future contains a RDFParser.ParseResult. Implementations may subclass this interface to provide any parser details, e.g. list of warnings. null is a possible return value if no details are available, but parsing succeeded.
    If an exception occurs during parsing, (e.g. IOException or org.apache.commons.rdf.simple.experimental.RDFParseException), it should be indicated as the Throwable.getCause() in the ExecutionException thrown on Future.get().
    
    Specified by:
    
    parse in interface RDFParser
    
    Returns:
    
    A Future that will return the populated Graph when the parsing has finished.
    
    Throws:
    
    IOException - If an error occurred while starting to read the source (e.g. file not found, unsupported IRI protocol). Note that IO errors during parsing would instead be the Throwable.getCause() of the ExecutionException thrown on Future.get().
    
    IllegalStateException - If the builder is in an invalid state, e.g. a source has not been set.
  - target
```
public T target(Consumer<Quad> consumer)
```
    Description copied from interface: RDFParser
    Specify a consumer for parsed quads.
    The quads will include triples in all named graphs of the parsed source, including any triples in the default graph. When parsing a source format which do not support datasets, all quads delivered to the consumer will be in the default graph (e.g. their Quad.getGraphName() will be as Optional.empty()), while for a source
    It is undefined if any quads are consumed if RDFParser.parse() throws any exceptions. On the other hand, if RDFParser.parse() does not indicate an exception, the implementation SHOULD have produced all parsed quads to the specified consumer.
    Calling this method will override any earlier targets set with RDFParser.target(Graph), RDFParser.target(Consumer) or RDFParser.target(Dataset).
    The consumer is not assumed to be thread safe - only one Consumer.accept(Object) is delivered at a time for a given RDFParser.parse() call.
    This method is typically called with a functional consumer, for example:
```
 
 List<Quad> quads = new ArrayList<Quad>;
 parserBuilder.target(quads::add).parse();
 
 
```
    Specified by:
    
    target in interface RDFParser
    
    Parameters:
    
    consumer - A Consumer of Quads
    
    Returns:
    
    An RDFParser that will call the consumer for into the specified dataset.
  - target
```
public T target(Dataset dataset)
```
    Description copied from interface: RDFParser
    
    Specify a Dataset to add parsed quads to.
    It is undefined if any quads are added to the specified Dataset if RDFParser.parse() throws any exceptions. (However implementations are free to prevent this using transaction mechanisms or similar). On the other hand, if RDFParser.parse() does not indicate an exception, the implementation SHOULD have inserted all parsed quads to the specified dataset.
    Calling this method will override any earlier targets set with RDFParser.target(Graph), RDFParser.target(Consumer) or RDFParser.target(Dataset).
    The default implementation of this method calls RDFParser.target(Consumer) with a Consumer that does Dataset.add(Quad).
    
    Specified by:
    
    target in interface RDFParser
    
    Parameters:
    
    dataset - The Dataset to add quads to.
    
    Returns:
    
    An RDFParser that will insert triples into the specified dataset.
  - target
```
public T target(Graph graph)
```
    Description copied from interface: RDFParser
    
    Specify a Graph to add parsed triples to.
    If the source supports datasets (e.g. the RDFParser.contentType(RDFSyntax) set has RDFSyntax.supportsDataset() is true)), then only quads in the default graph will be added to the Graph as Triples.
    It is undefined if any triples are added to the specified Graph if RDFParser.parse() throws any exceptions. (However implementations are free to prevent this using transaction mechanisms or similar). If Future.get() does not indicate an exception, the parser implementation SHOULD have inserted all parsed triples to the specified graph.
    Calling this method will override any earlier targets set with RDFParser.target(Graph), RDFParser.target(Consumer) or RDFParser.target(Dataset).
    The default implementation of this method calls RDFParser.target(Consumer) with a Consumer that does Graph.add(Triple) with Quad.asTriple() if the quad is in the default graph.
    
    Specified by:
    
    target in interface RDFParser
    
    Parameters:
    
    graph - The Graph to add triples to.
    
    Returns:
    
    An RDFParser that will insert triples into the specified graph.

Class AbstractRDFParser<T extends AbstractRDFParser<T>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.commons.rdf.experimental.RDFParser

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

threadGroup

Constructor Detail

AbstractRDFParser

Method Detail

getRdfTermFactory

getContentTypeSyntax

getContentType

getTarget

getTargetDataset

getTargetGraph

getBase

getSourceInputStream

getSourceFile

getSourceIri

clone

asT

rdfTermFactory

contentType

contentType

base

base

source

source

source

source

checkIsAbsolute

checkSource

checkBaseRequired

resetSource

resetTarget

parseSynchronusly

prepareForParsing

checkTarget

checkContentType

guessRDFSyntax

createRDFTermFactory

parse

target

target

target