All Classes and Interfaces
Class
Description
Abstract base for instruction copying values from one
memory cell to some other.Abstract base for
instruction parsers parsing a single named
instruction encoded with parameters separated by whitespace.Instruction that adds constant to value held in working
memory cell.Collection of utility functions for simplifying manipulation of JavaFX bindings.
Bootstraps all needed application components.
Main class of the CodeGame application handling the application launch.
Implementation of a compiler, which computes CSS highlight styles for individual parts of a source code
using the CodeGame syntax.
Implementation of a compiler, which compiles source code into an executable
program using
the CodeGame syntax.Memory holding constant number of
memory cells specified during its creation.Instruction that copies value from target
memory cell to working memory cell.Instruction that copies value from working
memory cell to target memory cell.Implementation of an
instruction parser that delegates parsing to other provided
parsers.Implementation of business logic related to evaluation of solutions of
problems.Parses a named
instruction with a single address parameter by requesting it
from a backing factory.Parses a named
instruction with a single integer parameter by requesting it
from a backing factory.Produces
instructions from a single integer parameter.Parses a named
instruction with a single parameter by requesting it
from a backing factory.Produces
instructions from a single string parameter.Provides JavaFX views by loading raw FXML views from the
IFxmlViewSourceProvider.Produces JavaFX
alerts.Produces controllers for the JavaFX views.
Service for presenting popup dialogs to the user.
Service that manages business logic related to evaluation of solutions of
problems
created by the player.Algorithm that evaluates if the
execution context has reached a state,
where it satisfies rules as a valid solution of a problem case.Context of a single execution, which provides access to all components related to the execution.
Engine responsible for an instruction execution within its
execution context.Service that manages business logic related to execution.
Produces JavaFX
fxml loaders ready for loading of views.Manages the JavaFX FXML sources for views.
Computes CSS highlight styles for individual parts of a source code for the library RichTextFX.
Source of input values during execution.
Produces
input sources.Instruction is an elementary operation that modifies state of the
execution context.Parses
instructions encoded in strings.Provides a simple way to manage an existing subscription to a JavaFX
observable.Collection of
memory cells which can hold an integer value.Cell in a memory that can hold a single integer value.
Produces
memory cells.Observes value changes of a
memory cell and notifies listeners about new values.Produces
memory.Service that manages business logic related to
memory.Implementation of the
execution context, where individual components cannot be
changed during the execution.Immutable implementation holding details about an error in user's solution
to a
problem.Immutable provider for JavaFX
stages used by the application for presentation.Immutable provider for stylesheets for JavaFX views.
Handles navigation between routes of the application.
Instruction that takes next value from
input source and copies it to the working
memory cell.Instruction descriptors provide additional context to individual
instructions during
the program execution.Thrown when an illegal state during instruction execution is reached.
Thrown when parsing of an
instruction fails.Thrown when a source code contains an invalid syntax.
Destination of output values during execution that expects values until it becomes
satisfied.Produces
output sinks.Manages logic and state related to the selection of
problem to be solved by the user.Handles storage of
problems used by the application.Service that manages business logic related to management of problems available to the application.
Interface for simplifying
program creation process.Produces
program builders.Compiler takes a source code and compiles it into an executable
program.Holds details about an error in user's solution to a
problem.Produces
solution error models for exceptions relevant
to user's solutions.Evaluates an underlying
execution context on set rules.Manages logic and state related to user's solution to a given
problem.Manages the JavaFX
stages used by the application for presentation.Input source that uses an iterable as source of inputs.Manages the JavaFX views used by application for presentation.
Manages the stylesheets for JavaFX views.
Implementation of a service for presenting popup dialogs to the user using JavaFX.
Instruction that performs a jump of the
engine to the specified label if
the value of the working memory cell is equal to zero.Instruction that performs a jump of the
engine to the specified label.Entrypoint for fat jar deployed version of CodeGame.
Implementation of business logic related to
memory.JavaFX control presenting the state of a memory during execution.
Thrown when a step is attempted, but engine has no next instruction.
Thrown by
output sink after it rejects an output value.Instruction that emits current value in working
memory cell to output sink.Implementation of the
evaluation strategy that checks if the
output sink in the execution context is satisfied.Collection of utility functions for checking validity of arguments.
Problem is a challenge solvable by player.
Problem case describes a test case of a
problem, which is used to validate player solution.Problem cases memory settings contains memory settings, which are used to configure execution memory
during validation of player's solution.
Controller for the problem list view that manipulates provided
problem list model.Implementation of problem list model using
problems
managed by problem service.Implementation of business logic related to management of problems available to the application that uses
provided problem repository as source of problems.
Program is a set of instructions to be followed during execution.
Simple implementation for building
programs based on the required rules.Implementation of the
execution engine that executes a program.Implementation of business logic related to execution.
Provides the JavaFX FXML sources from resources of the specified class for specified views.
Thrown when an error occurs during application resource loading.
Simple
memory cell that does not hold any value from the start.Simple implementation of navigation which treats requested navigation routes as view ids.
Controller for the solution view that manipulates provided
solution model.Implementation of a
solution evaluator that evaluates an underlying
execution context against a specific problem case using
an evaluation strategy.Implementation of
solution model evaluating solution created by player.Thrown during the evaluation step if the evaluation reaches an undesired state.
Thrown when an exception is thrown during instruction execution while engine is doing a step.
Parses a named
instruction without parameters by requesting it from supplier.Thrown during the evaluation step if maximum allowed number of steps was reached.
Enforces maximum step count for a given evaluation.
Thrown when a jump is attempted, but the jump label is unknown to the engine.
Thrown when navigation is attempted, but the route is not known by the navigator.
Thrown when a component does not recognize a view.
Adapts existing
memory cell by observing its value when manually requested
using the UpdatableMemoryCellObserverAdapter.updateValue() method.Output sink that matches execution outputs to values from input source.