AbstractRDFParser (Commons RDF impl: Simple 0.5.0 API)

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

All Implemented Interfaces:

Cloneable, RDFParser
```
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)`
`T`	`base(String base)`
`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)`
`T`	`contentType(String contentType)`
`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()`
`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)`
`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)`
`T`	`source(IRI iri)`
`T`	`source(Path file)`
`T`	`source(String iri)`
`T`	`target(Consumer<Quad> consumer)`
`T`	`target(Dataset dataset)`
`T`	`target(Graph graph)`

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)
```
    Specified by:
    
    rdfTermFactory in interface RDFParser
  - contentType
```
public T contentType(RDFSyntax rdfSyntax)
              throws IllegalArgumentException
```
    Specified by:
    
    contentType in interface RDFParser
    
    Throws:
    
    IllegalArgumentException
  - contentType
```
public T contentType(String contentType)
              throws IllegalArgumentException
```
    Specified by:
    
    contentType in interface RDFParser
    
    Throws:
    
    IllegalArgumentException
  - base
```
public T base(IRI base)
```
    Specified by:
    
    base in interface RDFParser
  - base
```
public T base(String base)
       throws IllegalArgumentException
```
    Specified by:
    
    base in interface RDFParser
    
    Throws:
    
    IllegalArgumentException
  - source
```
public T source(InputStream inputStream)
```
    Specified by:
    
    source in interface RDFParser
  - source
```
public T source(Path file)
```
    Specified by:
    
    source in interface RDFParser
  - source
```
public T source(IRI iri)
```
    Specified by:
    
    source in interface RDFParser
  - source
```
public T source(String iri)
         throws IllegalArgumentException
```
    Specified by:
    
    source in interface RDFParser
    
    Throws:
    
    IllegalArgumentException
  - 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
```
    Specified by:
    
    parse in interface RDFParser
    
    Throws:
    
    IOException
    
    IllegalStateException
  - target
```
public T target(Consumer<Quad> consumer)
```
    Specified by:
    
    target in interface RDFParser
  - target
```
public T target(Dataset dataset)
```
    Specified by:
    
    target in interface RDFParser
  - target
```
public T target(Graph graph)
```
    Specified by:
    
    target in interface RDFParser

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