org.aksw.jena_sparql_api.io.filter.sys

Class FilterExecutionFromSysFunction

java.lang.Object

org.aksw.jena_sparql_api.io.filter.sys.FilterExecutionFromSysFunction

All Implemented Interfaces:

FilterConfig

public class FilterExecutionFromSysFunction
extends Object
implements FilterConfig

Field Summary

Fields

Modifier and Type	Field and Description
protected SysCallFn	cmdFactory
protected FilterMetadata	filterMetadata
static Path	PROBE_PATH
protected Destination	source

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	FilterExecutionFromSysFunction(SysCallFn cmdFactory, Destination source)

Method Summary

Modifier and Type	Method and Description
protected Path	allocateInputFile()
protected Path	allocateOutputFile()
io.reactivex.rxjava3.core.Single<HotFile>	awaitOrAllocateInputFileAndFilterToFile(Destination effectiveSource, Path tgtPath)
io.reactivex.rxjava3.core.Single<HotFile>	awaitOrAllocateInputFileAndFilterToFileCore(io.reactivex.rxjava3.core.Single<? extends FileCreation> fileCreation, Path tgtPath)
io.reactivex.rxjava3.core.Single<InputStreamSupplier>	awaitOrAllocateInputFileAndFilterToStream(Destination effectiveSource)
io.reactivex.rxjava3.core.Single<InputStreamSupplier>	execStream() Actually execute the filter Because we always prefer streams over files (which get passed as arguments), we check the availability and applicability of commands of the cmdFactory in the following order: - stream to stream - stream to file (we can stream the file being generated) - file to stream - file to file the 'file to stream' cases will try to reuse files under generation in the source destination Invokes ifNeedsFileInput and ifNeedsFileOutput handlers as needed
io.reactivex.rxjava3.core.Single<HotFile>	execToHotFile(Path tgtPath) Execute the stream and write the result to a hot file TODO What if the input is a hot file? We can wait for file completion or we can connect to its stream.
Path	extractKnownPathFromDestination(Destination destination)
static io.reactivex.rxjava3.core.Single<? extends FileCreation>	forceDestinationToFile(io.reactivex.rxjava3.core.Single<InputStreamSupplier> xxx, Path tmpFile)
io.reactivex.rxjava3.core.Single<? extends FileCreation>	forceInputFileCreation(Destination effectiveSource)
Destination	getEffectiveSource()
FilterConfig	ifNeedsFileInput(Supplier<Path> pathRequester, BiConsumer<Path,FileWritingProcess> processCallback)
FilterConfig	ifNeedsFileOutput(Supplier<Path> pathRequester, BiConsumer<Path,FileWritingProcess> processCallback)
DestinationFromFileCreation	outputToFile(Path path) If explicit output to a file is requested, the handler set via ifNeedsFileOutput will not be called.
Destination	outputToStream() If the execution requires the generation of an intermediate file, the handler for ifNeedsFileOutput should be called
FilterConfig	pipeInto(FilterEngine nextFilter)
boolean	requiresFileOutput() Actually execute the stream and write the result to a file
String	toString()
io.reactivex.rxjava3.core.Single<? extends FileCreation>	tryGetFileCreation(Destination destination)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

PROBE_PATH

public static final Path PROBE_PATH

cmdFactory

protected SysCallFn cmdFactory

filterMetadata

protected FilterMetadata filterMetadata

source

protected Destination source

Constructor Detail

FilterExecutionFromSysFunction

protected FilterExecutionFromSysFunction(SysCallFn cmdFactory,
                                         Destination source)

Method Detail

requiresFileOutput

public boolean requiresFileOutput()

Actually execute the stream and write the result to a file

Specified by:

requiresFileOutput in interface FilterConfig

Parameters:

path -

Returns:

extractKnownPathFromDestination

public Path extractKnownPathFromDestination(Destination destination)

allocateInputFile

protected Path allocateInputFile()

allocateOutputFile

protected Path allocateOutputFile()

getEffectiveSource

public Destination getEffectiveSource()

execToHotFile

public io.reactivex.rxjava3.core.Single<HotFile> execToHotFile(Path tgtPath)

Execute the stream and write the result to a hot file TODO What if the input is a hot file? We can wait for file completion or we can connect to its stream. We always prefer the stream, unless the file is already ready, because in that case we may be able to skip the JVM

Parameters:

tgtPath -

Returns:

tryGetFileCreation

public io.reactivex.rxjava3.core.Single<? extends FileCreation> tryGetFileCreation(Destination destination)

awaitOrAllocateInputFileAndFilterToFile

public io.reactivex.rxjava3.core.Single<HotFile> awaitOrAllocateInputFileAndFilterToFile(Destination effectiveSource,
                                                                                         Path tgtPath)

forceDestinationToFile

public static io.reactivex.rxjava3.core.Single<? extends FileCreation> forceDestinationToFile(io.reactivex.rxjava3.core.Single<InputStreamSupplier> xxx,
                                                                                              Path tmpFile)

forceInputFileCreation

public io.reactivex.rxjava3.core.Single<? extends FileCreation> forceInputFileCreation(Destination effectiveSource)

awaitOrAllocateInputFileAndFilterToFileCore

public io.reactivex.rxjava3.core.Single<HotFile> awaitOrAllocateInputFileAndFilterToFileCore(io.reactivex.rxjava3.core.Single<? extends FileCreation> fileCreation,
                                                                                             Path tgtPath)

awaitOrAllocateInputFileAndFilterToStream

public io.reactivex.rxjava3.core.Single<InputStreamSupplier> awaitOrAllocateInputFileAndFilterToStream(Destination effectiveSource)

execStream

public io.reactivex.rxjava3.core.Single<InputStreamSupplier> execStream()

Actually execute the filter Because we always prefer streams over files (which get passed as arguments), we check the availability and applicability of commands of the cmdFactory in the following order: - stream to stream - stream to file (we can stream the file being generated) - file to stream - file to file the 'file to stream' cases will try to reuse files under generation in the source destination Invokes ifNeedsFileInput and ifNeedsFileOutput handlers as needed

Specified by:

execStream in interface FilterConfig

ifNeedsFileInput

public FilterConfig ifNeedsFileInput(Supplier<Path> pathRequester,
                                     BiConsumer<Path,FileWritingProcess> processCallback)

Specified by:

ifNeedsFileInput in interface FilterConfig

ifNeedsFileOutput

public FilterConfig ifNeedsFileOutput(Supplier<Path> pathRequester,
                                      BiConsumer<Path,FileWritingProcess> processCallback)

Specified by:

ifNeedsFileOutput in interface FilterConfig

pipeInto

public FilterConfig pipeInto(FilterEngine nextFilter)

Specified by:

pipeInto in interface FilterConfig

outputToFile

public DestinationFromFileCreation outputToFile(Path path)

Description copied from interface: FilterConfig

If explicit output to a file is requested, the handler set via ifNeedsFileOutput will not be called.

Specified by:

outputToFile in interface FilterConfig

Returns:

outputToStream

public Destination outputToStream()

Description copied from interface: FilterConfig

If the execution requires the generation of an intermediate file, the handler for ifNeedsFileOutput should be called

Specified by:

outputToStream in interface FilterConfig

Returns:

toString

public String toString()

Overrides:

toString in class Object