All Classes and Interfaces
Class
Description
Abstract base for exporters that serialise a single
JustificationModel to text.A placeholder element in a template, to be substituted when the template is
implemented.
Create a list of commands to build a model out of a parse tree.
Adds a pre-built element to a justification model.
Establishes a support edge between two elements that already exist in the
same justification model.
Mutable registry that maps original element ids to the merged id chosen
during Phase 1 of
CompositionOperator.apply(String, List, Map).A deferred
MacroCommand that expands an operator call into the
Commands needed to build the result model.Built-in
assemble composition operator.Pipeline sink that writes a
byte[] to an OutputStream
supplied at construction time.Fluent builder that accumulates
Transformations into a compilation
chain.Delegate to ANTLR the transformation of an input stream into a
character-based one.
An idempotent pipeline step: inspects the value without modifying it.
Functional interface for the
Transformation.of(Transformation.Step) factory.A command in the command pattern for model construction.
Thrown by
ExecutionEngine when a command's condition is satisfied but
its execution throws a RuntimeException.Sealed interface for elements that can appear in both justifications and
templates.
Immutable configuration for a single process-mode compilation run.
Mutable context threaded through every step of a compilation pipeline.
Unchecked exception thrown when a compilation step fails unexpectedly.
Contract for a compiler: consume an input file and produce an output file.
Assembles a
Compiler from a CompilationConfig by wiring the
appropriate pipeline steps.Pipeline step that checks all models in a
Unit for structural
completeness.Checks that justification models are structurally complete.
Base class for all composition operators.
The top-level conclusion that a justification aims to establish.
Pipeline step that checks all models in a
Unit for structural
consistency.Checks structural invariants of justification models.
Creates an
AbstractSupport inside a template.Creates a
Conclusion inside a justification or template.Creates an
Evidence inside a justification.Creates a
Justification inside a unit.Creates a
Strategy inside a justification.Creates a
SubConclusion inside a justification.Creates a
Template inside a unit.Thrown by
ExecutionEngine when execution deadlocks — all remaining
commands have unsatisfied conditions and cannot make progress.A single diagnostic message produced during compilation.
Compiler diagnostic error-code tags embedded in error messages.
Produces a human-readable diagnostic report from the compiled
Unit
and the CompilationContext.Serialises a single
JustificationModel to Graphviz DOT text, ready to
be compiled by dot.Sealed interface common to all element-creation commands.
One cell of the partition computed by
CompositionOperator: a
non-empty list of SourcedElements that are all equivalent under the
operator's EquivalenceRelation.Read-only view of an element's identity: its
id and label.Binary predicate that decides whether two
ElementViews belong to the
same equivalence class and should therefore be merged.A leaf evidence element supporting a strategy.
A record of a single action that took place during execution: either a
RegularCommand that was executed, or a MacroCommand that was
expanded.Executes a sequence of commands against a
Unit, handling deferred
execution for commands whose condition is not yet met.Compilation step that serialises a
JustificationModel to Graphviz DOT
text.Compilation step that serialises a
JustificationModel to .jd
source text.Compilation step that serialises a
JustificationModel to JSON text.Compilation step that serialises a
JustificationModel to Python
source text.Pipeline source that opens a file and provides it as an
InputStream.Output formats supported by the compiler.
Converts accumulated non-fatal errors into a fatal signal, aborting the
pipeline at the next step boundary.
Links a justification model to the
Template it implements, by setting
the template as the model's parent.Thrown by
CompositionOperator.apply(String, List, Map) when one or more required
argument keys are missing from the provided argument map.This class provides an empty implementation of
JPipeListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.Serialises a compiled jPipe model back to
.jd source text conforming
to the jPipe grammar.This interface defines a complete listener for a parse tree produced by
JPipeParser.Serialises a single
JustificationModel to JSON text.A concrete justification model.
Sealed root of the element hierarchy.
Abstract base for all named justification models.
Visitor over the jPipe model hierarchy.
Converts a human-readable jPipe element label into a valid Python identifier
(snake_case).
Delegate to ANTLR the task of "lexing" the character stream into relevant
tokens.
Eliminates all
LoadResolver.LoadDirectives from the command list by recursively
parsing each referenced file and splicing its prefixed commands in place.A command that expands into a list of
RegularCommands at execution
time.jPipe CLI entry point.
Describes how to create the merged element for one
ElementGroup.Discriminates between the two concrete subtypes of
JustificationModel
that a CompositionOperator can produce.Convenience base class for visitors that only need to handle a subset of the
model hierarchy.
Describes a single operator call: what result to produce, which operator to
invoke, the source models, call-site arguments, source location, and the
declared result kind.
Name-to-
CompositionOperator registry.Replaces an
AbstractSupport placeholder (inlined from a template)
with a concrete element.Delegate to ANTLR the transformation of a token stream into a parse tree.
Serialises a single
JustificationModel to a Python module: each
element becomes a decorated function named after the element's label
(snake_case via LabelEscaper).Built-in
refine composition operator.Records that
oldId inside a result model is an alias for the merged
element newId.Base class for commands that execute directly on a
Unit.Removes an element by id from a justification model.
Compilation step that renders DOT text to a binary image format by invoking
the
dot command-line tool.Replaces a strategy's current supporter with the element at
newSupporterId.Two elements are equivalent iff they share the same label, regardless of
their ids or source models.
Two elements are equivalent iff their ids are identical after stripping any
namespace prefix (the last colon-separated segment).
Extracts a single
JustificationModel from a Unit by name, or
auto-selects it when the unit contains exactly one model and no name is
given.Last step of a compilation chain: serialises the pipeline output to a file.
First step of a compilation chain: reads an input file and produces the
initial value fed to the first
Transformation.Functional interface for the
Source.of(Source.Provider) factory.Pairs a
JustificationElement with the model it was taken from and its
original source location, so merge functions can inspect the element in its
original context and forward the location to creation commands.Immutable source position at which a named element was declared.
A reasoning strategy connecting evidence to a conclusion.
Sealed interface for elements that receive support from exactly one
Strategy.Pipeline sink that writes a
String to an OutputStream
supplied at construction time.An intermediate conclusion within a justification.
Marker interface for elements that can act as direct support in a
justification graph:
SubConclusion, Evidence, and
AbstractSupport.A reusable justification template (pattern).
A single step in a compilation chain: a function
I → O.Functional interface for the
Transformation.of(Transformation.Step) factory — allows steps to be
expressed as lambdas or method references.Name-to-
EquivalenceRelation registry used by Unifier for the
automatic post-composition unification phase.Phase 4 post-processor for composition operators.
Root of a compiled jPipe file.
A single rule violation found during consistency or completeness validation.