an Interpreter that calls this importer to interpret a parsing stream

This Interpreter is only applicable if it can determine an archive that the parsing stream is created from. In that case, it will import the file, i.e., change the state of the archive.

object interpretation

structure interpretation

the main function to run the build target

en empty in filepath addresses the whole archive

entry point for recursive building

delegates to build

similar to buildFile but called on every directory (after all its children have been processed)

This does nothing by default and can be overridden if needed.

the main abstract method for building one file

converts the interface of Importer to the one of Parser

like its partner but with return value

convenience method for wrapping code in error handler that throws LocalError

recursively delete output files in parallel (!)

additional method that implementations may provide: cleans one directory

does nothing by default

additionally deletes content and relational

the controller that this extension is added to; only valid after creation of the extension, i.e., will return null if used in a non-lazy val-field

auxiliary method for deleting a file

extension-specific cleanup (override as needed, empty by default)

Extensions may create persistent data structures and threads, but they must clean up after themselves in this method

convenience for calling waitUntilRemainingTasksFinished and then destroy

estimate the BuildResult without building, e.g., to predict dependencies

the name that is used for the special file representing the containing folder (without extension), empty by default

the input format (e.g., the file extension) to which this interpreter is applicable

creates a ParsingStream for the input file and interprets it

source by default, may be overridden

the file extensions to which this may be applicable

true by default; override to skip auxiliary directories

there is no inExt, instead we test to check which files should be used; this is often a test for the file extension

This must be such that all auxiliary files are skipped. see defaultFileExtension if you need an inExt (for meta targets)

any extension can initialize other extensions if those are not meant to be added to the ExtensionManager

a string identifying this build target, used for parsing commands, logging, error messages

logs an error - always logged

logs a message with this logger's logprefix

log as an error message

wraps around a group to create nested logging

defaults to the key

auxiliary method for logging results

temporary logging - always logged

makes a build task for a single file (ignoring built children) or directory

an ErrorHandler that wraps an error in a LocalError and throws it

narration, produces also content and relational

omdoc

if true, multiple files/folders are built in parallel

if this target produces additional files (e.g., the aux files of LaTeX), this method should map them to the respective main file

wraps around buildFile and buildDir (which do the actual building) to add error handling, logging, etc.

the entry point for build managers: runs a build task unless (depending on the modifier) nothing has changed

extension-specific initialization (override as needed, empty by default)

extensions that process tasks in separate threads should override this and wait until those threads are done

extract the notations of a knowledge item and write them to a file

extract the relational information about a knowledge item and write it to a file

build estimated dependencies first

this can be used by the trivial build manager to build targets (like latexml) in dependency order provided that estimated dependencies are correct.

For a queue build manager this code is obsolete