Package-level declarations
Types
Base implementation of every :solve-prolog it.unibo.tuprolog.solve.Solver/it.unibo.tuprolog.solve.MutableSolver (PrologSolver and MutablePrologSolver, both internal, are the only two concrete subclasses; instances are normally obtained through Arg2pPrologSolverFactory, which is what the Solver.prolog property resolves to).
The SolverFactory of the engine of arg2p, the fork of 2P-Kt's ISO-standard, SLD-NF resolution engine (:solve-prolog) that inlines module calls and keeps the bindings of the goals left to solve (see README.md in this package). The solvers of arg2p are built with it (Arg2pSolverFactory); it is public for the tools building their own.
One node of the :solve-prolog choice-point queue: a saved point in the proof search that it.unibo.tuprolog.argumentation.core.engine.fsm.StateBacktracking can resume from, chained to its parent to form the full lineage of choice points recorded since the query started (see pathToRoot).
Told of each clause the engine resolves a goal with (arg2p): to measure which clauses a run uses
The observers of the clauses resolved by the engine, in any resolution of any solver while they are registered: an instrument for tools such as coverage reports, costing a check of an empty list otherwise.
Where the engine finds the clauses it resolves a goal with (arg2p): the theories of the program, or the source of a Sourcing delegation.
A primitive whose goal the engine can solve itself, as a sub-goal of the same resolution, rather than through the solutions the primitive computes (arg2p: module calls, context lookups). Other solvers just call solve.
How the engine solves a DelegatedCall, in a frame of its own opaque to cut (as call/1)
The goal solved in place, against the libraries given: when the frame is left, the caller goes on with its own libraries (module calls)
One frame of the :solve-prolog execution-context stack: a substitution, the streams of remaining goals, candidate Rules and candidate primitive responses, plus a parent link. Frames chain into their parent rather than living in a separate stack container, so the parent chain (see pathToRoot) is the call stack -- ordinary heap-allocated data rather than native JVM/JS stack frames, which is what lets Prolog resolution of arbitrarily deep recursive programs run as an explicit, non-recursive it.unibo.tuprolog.argumentation.core.engine.fsm.State loop instead of unbounded host-language recursion.
The goals selected so far in a frame, the newest first: a chain extended at each step, rather than the set of their variables (arg2p: copying the set at each step made long conjunctions quadratic). The variables are only collected when a substitution is trimmed.
Drives the :solve-prolog finite-state machine, one State.next step at a time, and turns every visited end-state (see it.unibo.tuprolog.argumentation.core.engine.fsm.EndState) into an emitted Solution.
The goal (not a conjunction) resolved with the clauses of source as the clauses of its predicate, read when the call is made (context lookups)
Functions
Chains a new ChoicePointContext.Primitives recording alternatives onto this (null meaning "the root").
Chains a new ChoicePointContext.Rules recording alternatives onto this (null meaning "the root").
The ChoicePointContext.depth a new choice point chained onto this one (or null, for the root) would have.