Classes

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234567]

Porg
Plflang
Panalyses
Pc
CAbstractAstVisitor	Modeled after AbstractParseTreeVisitor
CAstUtils
CAstVisitor	Modeled after ParseTreeVisitor.class
CBuildAstParseTreeVisitor	This visitor class builds an AST from the parse tree of a C program
CCAst
CAdditionNode	Arithmetic operations
CAssignmentNode
CAstNode
CAstNodeBinary
CAstNodeDynamic	An AST node class that can have a list of child nodes with arbitrary length
CAstNodeUnary
CDivisionNode
CEqualNode	Comparison operators
CGreaterEqualNode
CGreaterThanNode
CIfBlockNode	AST node for an IF block
CIfBodyNode	AST node for the body of an IF block
CLessEqualNode
CLessThanNode
CLiteralNode
CLogicalAndNode
CLogicalNotNode
CLogicalOrNode
CMultiplicationNode
CNegativeNode
CNotEqualNode
COpaqueNode	An Ast node that indicates the code represented by this node is unanalyzable
CScheduleActionIntNode	AST node for a lf_schedule_int(action, additional_delay, integer) call
CScheduleActionNode	AST node for a lf_schedule(action, additional_delay) call
CSetPortNode	LF built-in operations
CStatementSequenceNode
CStateVarNode	Handle state variables appearing as self-><name>
CSubtractionNode
CTriggerIsPresentNode	Handle trigger presence appearing as <name>->is_present
CTriggerValueNode	Handle trigger values appearing as <name>->value
CVariableNode
CType
CCAstVisitor	Modeled after CVisitor.java
CCBaseAstVisitor	A base class that provides default implementations of the visit functions
CCToUclidVisitor
CIfNormalFormAstVisitor	An AST visitor that converts an original AST into the If Normal Form
CVariablePrecedenceVisitor	This visitor marks certain variable node as "previous."
CVisitable
Pstatespace
CEvent	A node in the state space diagram representing a step in the execution of an LF program
CEventQueue	An event queue implementation that sorts events in the order of time tags and trigger names based on the implementation of compareTo() in the Event class
CStateInfo	A class that represents information in a step in a counterexample trace
CStateSpaceDiagram	A directed graph representing the state space of an LF program
CStateSpaceExplorer	(EXPERIMENTAL) Explores the state space of an LF program
CStateSpaceNode	A node in the state space diagram representing a step in the execution of an LF program
CTag	Class representing a logical time tag, which is a pair that consists of a timestamp (type long) and a microstep (type long)
Puclid
CMTLVisitor	(EXPERIMENTAL) Transpiler from an MTL specification to a Uclid axiom
CUclidGenerator	(EXPERIMENTAL) Generator for Uclid5 models
CTactic	A tactic used to verify properties
CUclidRunner	(EXPERIMENTAL) Runner for Uclid5 models
Past
CAstTransformation	Interface for AST Transfomations
CASTUtils	A helper class for modifying and analyzing the AST
CDelayedConnectionTransformation	This class implements AST transformations for delayed connections
CFormattingUtil	Utility functions that determine the specific behavior of the LF formatter
CIsEqual	Switch class that checks if subtrees of the AST are semantically equivalent to each other
CLfParsingHelper	Utility to parse LF classes
CMalleableString	A MalleableString is an object with multiple valid textual representations
CBuilder	Build a MalleableString in a manner analogous to the way we build Strings
CJoiner	Join MalleableStrings together using the given separator
CToLf	Switch class for converting AST nodes to their textual representation as it would appear in LF code
CToSExpr	Converts an LF model to an S-expression
CSExpr
CSList
CSAtom
CToText	Switch class for converting AST nodes to some textual representation that seems likely to be useful for as many code generators as possible
Pcli
CCliBase	Base class for standalone CLI applications
CMutuallyExclusive	Options and parameters present in both Lfc and Lff
CCliToolTestFixture	Test utilities for a CLI tool, eg org.lflang.cli.Lfc, org.lflang.cli.Lff
CDiagramGenerationTest
CLfc	Standalone version of the Lingua Franca compiler (lfc)
CThreadingMutuallyExclusive	Mutually exclusive options related to threading
CLfcCliTest
CLfcOneShotTestFixture
CLfcTestFixture
CLFCliSetup	Setup for Cli module registration
CLfd	Command lin tool for generating diagrams from Lingua Franca programs
CLfdCliTest
CLfdTestFixture
CLff	Standalone version of the Lingua Franca formatter (lff)
CLffCliTest
CLffTestFixture
CLFStandaloneModule	Module that is only available when running LFC as a standalone program
CStandaloneIssueAcceptor	Collects issues from the code generator and reports them to the user
CStandaloneMessageReporter	An error reporter that forwards all messages to an IssueCollector
CTestUtils
CTempDirBuilder	Builder for a directory
CTempDirChecker	Builder for a directory
CVersionProvider
Pdiagram
Plsp
CBuildArgs	Build arguments for the diagram server
CLanguageDiagramServer	Language server with extended diagram communication
CLFLanguageClient	Language client for the diagram server
CLFLanguageServer	The Lingua Franca language and diagram server
CLFLanguageServerExtension	Provide Lingua-Franca-specific extensions to the language server's behavior
CLibraryFile	Represents a Lingua Franca (LF) file
CNodePosition	Position of a node within a text document or code file
CProgress	A class for reporting the progress of an ongoing task
CReactorNode	Represents a node in a hierarchical structure where each node has a label, a URI, and positional information
Psynthesis
Paction
CAbstractAction	Abstract super class for diagram actions that provides some convince methods
CCollapseAllReactorsAction	Action that expands (shows details) of all reactor nodes
CExpandAllReactorsAction	Action that collapses (hides details) of all reactor nodes
CFilterCycleAction	Action that filters the diagram for only those elements included in a cycle
CMemorizingExpandCollapseAction	Action for toggling collapse/expand state of reactors that memorizes the state and allows correct initialization synthesis runs for the same model
CShowCycleAction	Action that expands all reactor nodes that are included in a cycle
Ppostprocessor
CReactionPortAdjustment	Adjusts the port position of reactions node AFTER layout, to allow free port order but also adapt (snuggle) to pointy shape of reaction node
CReactorPortAdjustment	Adjusts the port figures of reactors when fixed side are off to keep the input output indication correct
Pstyles
CLinguaFrancaShapeExtensions	Extension class that provides shapes and figures for the Lingua Franca diagram synthesis
CLinguaFrancaStyleExtensions	Extension class that provides styles and coloring for the Lingua Franca diagram synthesis
CReactorFigureComponents	Components of a reactor figure
Putil
CCycleVisualization	Dependency cycle detection for Lingua Franca diagrams
CInterfaceDependenciesVisualization	Utility class to handle dependency edges for collapsed reactors in Lingua Franca diagrams
CLayoutPostProcessing	Set layout configuration options for the Lingua Franca diagram synthesis
CModeDiagrams	Transformations to support modes in the Lingua Franca diagram synthesis
CNamedInstanceUtil	Utility class to link KGraphElements to NamedInstances
CReactorIcons	Utility class to handle icons for reactors in Lingua Franca diagrams
CSynthesisMessageReporter	Message reporter for the Lingua Franca diagram synthesis
CUtilityExtensions	Extension class that provides various utility methods for the synthesis
CAbstractSynthesisExtensions	Abstract super class for extension classes used in for the diagram synthesis that provides some convince methods
CLinguaFrancaSynthesis	Diagram synthesis for Lingua Franca programs
CReactorParameterDisplayModes	Enumeration of different display options for reactor parameters
CSynthesisRegistration	Registration of all diagram synthesis related classes in Klighd
Pfederated
Pextensions
CCExtension	An extension class to the CGenerator that enables certain federated functionalities
CCExtensionUtils	Utility class for the C extension
CFedTargetExtension	Interface for federated target extensions
CFedTargetExtensionFactory	Class for instantiating target extensions
CPythonExtension	An extension class to the PythonGenerator that enables certain federated functionalities
CTSExtension	An extension class to the TSGenerator that enables certain federated functionalities
Pgenerator
CFedASTUtils	A helper class for AST transformations needed for federated execution
CFedConnectionInstance	Class representing a federated connection
CFedEmitter	Helper class to generate code for federates
CFederateInstance	Class that represents an instance of a federate, i.e., a reactor that is instantiated at the top level of a federated reactor
CFederateTargetConfig	Subclass of TargetConfig with a specialized constructor for creating configurations for federates
CFederationFileConfig	A subclass of {
CFedGenerator	The main class for the federated code generator
CFedImportEmitter	Helper class to generate import statements for a federate
CFedMainEmitter	Helper class to generate a main reactor
CFedPreambleEmitter	Helper class to generate preamble code for a federate
CFedReactorEmitter	Helper class to generate reactor definitions for a federate
CFedTargetEmitter	Helper class to generate target code for a federate
CFedUtils	A collection of utility methods for the federated generator
CLineAdjustingMessageReporter	A message reporter that adjusts line numbers to account for the fact that the code has been generated
CSynchronizedMessageReporter	A message reporter that synchronizes access to the parent reporter
Plauncher
CBuildConfig	A collection of methods used for building target code for federates
CCBuildConfig	Utility class that can be used to create a launcher for federated LF programs that are written in C
CFedLauncherGenerator	Utility class that can be used to create a launcher for federated LF programs
CPyBuildConfig	A build configuration for Python federates
CRtiConfig	Class for storing configuration settings pertaining to the RTI
CTsBuildConfig	Utility class that can be used to create a launcher for federated LF programs that are written in TypeScript
Pserialization
CFedCustomPythonSerialization	Enables support for custom serialization
CFedNativePythonSerialization	Enables support for Python pickle serialization
CFedROS2CPPSerialization	Enables support for ROS 2 serialization in C/C++ code
CFedSerialization	Interface to enable support for automatic data serialization in target code
CSupportedSerializers	The supported serializers
Pvalidation
CFedValidator	Helper class that is used to validate a federated reactor
Pformatting2
CLFFormatter
Pgenerator
Pc
CCActionGenerator	Generates code for actions (logical or physical) for the C and CCpp target
CCCmakeGenerator	A helper class that generates a CMakefile that can be used to compile the generated C code
CSetUpMainTarget	Provide a strategy for configuring the main target of the CMake build
CCCompiler	Responsible for creating and executing the necessary CMake command to compile code that is generated by the CGenerator
CCConstructorGenerator	Generates C constructor code for a reactor
CCCoreFilesUtils	Generates the list of files to be included in the core library for each reactor given conditions listed as arguments of each function
CCDelayBodyGenerator	Generate code for the bodies of the reactions involved in connections with the 'after' keyword
CCEnclavedReactorTransformation	The AST transformation enabling enclaved execution in the C target
CCEnclaveGenerator	This class is in charge of code generating functions and global variables related to the enclaves and environments
CCEnclaveGraph	This class contains the enclave connection graph
CCEnclaveInstance	An CEnclaveInstance object is associated with each enclave
CCFileConfig	The file configuration for the C target
CCMainFunctionGenerator	Generate the code that is the entry point of the program
CCMethodGenerator	Collection of functions to generate C code to declare methods
CCMixedRadixGenerator	Names for the variables used to index into the mixed-radix array
CCModesGenerator	Generates C code to support modal models
CCParameterGenerator	Generates C code to declare and initialize parameters
CCPortGenerator	Generates C code to declare and initialize ports
CCPreambleGenerator	Generates code for preambles for the C and CCpp target
CCReactionGenerator	Generate code for reactions
CCReactorHeaderFileGenerator	Generate user-visible header files
CGenerateAuxiliaryStructs	Functional interface for generating auxiliary structs such as port structs
CCStateGenerator	Generate code for state variables
CCTimerGenerator	Generates C code to declare and initialize timers
CCTracingGenerator	Generates C code to support tracing
CCTriggerObjectsGenerator	Generate code for the "_lf_initialize_trigger_objects" function
CCTypes	C-specific type information
CCUtil	A collection of utilities for C code generation
CReportCommandErrors	A ReportCommandErrors is a way to analyze command output and report any errors that it describes
CCWatchdogGenerator	Generate C code for watchdogs
CInteractingContainedReactors	Helper class to handle code generation of contained reactors
CTypeParameterizedReactor	A reactor class combined with concrete type arguments bound to its type parameters
Pdocker
CCDockerGenerator	Generate the docker file related code for the C and CCpp target
CDockerComposeGenerator	Code generator for docker-compose configurations
CDockerData	Build configuration of a docker service
CDockerGenerator	A class for generating docker files
CFedDockerComposeGenerator	A docker-compose configuration generator for a federated program
CPythonDockerGenerator	Generates the docker file related code for the Python target
CRtiDockerGenerator	Generate a Dockerfile for building the rti provided by reactor-c
CTSDockerGenerator	Generates the docker file related code for the Typescript target
Ppython
CPyFileConfig	Python file configuration
CPythonActionGenerator	Generate code for Python actions
CPythonDelayBodyGenerator	Generate code for the bodies of reactions that handle connections with logical delays specified with the after keyword
CPythonGenerator	Generator for Python target
CPythonMainFunctionGenerator	Responsible for creating the main function for the generated Python target programs
CPythonMethodGenerator	Collection of functions to generate Python code to declare methods
CPythonModeGenerator	Helper class to handle modes in Python programs
CPythonParameterGenerator	Generate Python code for parameters
CPythonPortGenerator	Generate Python code for ports
CPythonPreambleGenerator	Generate user-defined preambles and #define and #include directives for the Python target
CPythonReactionGenerator	Generate Python code for reactions
CPythonReactorGenerator	Generate Python code for reactors
CPythonStateGenerator	Generate Python code for state variables
CPythonTypes	Python-specific type information
CPythonValidator	A validator for generated Python code
CPyUtil	A collection of utilities for Python code generation
Prust
CCargoDependencySpec	Info about a cargo dependency
CCargoDependenciesPropertyType	The property type for the
Pts
CTSTypes	Type information for the Typescript target
CActionInstance	Instance of an action
CArgument	A record that ties a target property to a value obtained as a parameter to a compilation run
CCodeBuilder	Helper class for printing code with indentation
CCodeMap	Encapsulate data about the correspondence between ranges of generated code and ranges of a Lingua Franca file
CCorrespondence
CDeadlineInstance	Instance of a deadline
CDelayBodyGenerator	Interface for generating code for the body of reactions that handle connections with logical delays specified with the after keyword
CDiagnosticReporting	Utilities for reporting validation output
CStrategy	A means of parsing the output of a validator
CGenerationException	An exception that occurred during code generation
CGeneratorBase	Generator base class for specifying core functionality that all code generators should have
CErrorFileAndLine	Parsed error message from a compiler is returned here
CGeneratorCommandFactory	A factory class responsible for creating commands for use by the LF code generators
CGeneratorResult	The result of a code generation task
CStatus	A Status is a level of completion of a code generation task
CGetUserMessage	A GetUserMessage is a function that translates a GeneratorResult into a human-readable report for the end user
CGeneratorUtils	A helper class with functions that may be useful for code generators
CHumanReadableReportingStrategy	An error reporting strategy that parses human-readable output
CIntegratedBuilder	Manage Lingua Franca build processes that are requested from the language server
CReportProgress	A ProgressReporter reports the progress of a build
CInvalidLfSourceException	An exception that indicates invalid source, which should be reported to the user
CInvalidSourceException	This exception is thrown when a program fails a validity check performed by a code generator (and not the validator)
CLanguageServerMessageReporter	Report diagnostics to the language client
CLfExpressionVisitor	A visitor for expressions in LF
CDefaultLfVisitor	Base visitor class where methods are defaulted to a common one
CLfExpressionDeepCopyVisitor	A visitor that deep copies the expression
CLFGenerator	Generates code from your model files on save
CLFGeneratorContext	The context of a Lingua Franca build process
CMode
CMainContext	An LFGeneratorContext that is not nested in any other generator context
CMixedRadixInt	Representation of a permuted mixed radix (PMR) integer
CModeInstance	Representation of a runtime instance of a mode
CTransition
CNamedInstance	Base class for compile-time instances with names in Lingua Franca
CParameterInstance	Representation of a compile-time instance of a parameter
CPortInstance	Representation of a compile-time instance of a port
CPosition	A position in a document, including line and column
CRange	Represents a range in a document
CReactionInstance	Representation of a compile-time instance of a reaction
CRuntime	Inner class representing a runtime instance of a reaction
CReactionInstanceGraph	Analyze dependencies between reaction runtime instances
CReactorInstance	Representation of a compile-time instance of a reactor
CRuntimeRange	A representation of a range of runtime instance objects (port channels, reactors, reactions, etc.)
CPort	Special case of RuntimeRange for PortInstance
CSendRange	Class representing a range of a port that sources data together with a list of destination ranges of other ports that should all receive the same data sent in this range
CStateVariableInstance	Representation of a compile-time instance of a state variable
CSubContext	A SubContext is the context of a process within a build process
CTargetTypes	Information about the types of a target language
CTimerInstance	Instance of a timer
CTriggerInstance	Instance of a trigger (port, action, or timer)
CBuiltinTriggerVariable	This class allows to have BuiltinTriggers represented by a Variable type
CUnsupportedGeneratorFeatureException	Exception signaling that the code generator does not support a particular feature of the source language
CValidationStrategy	A means of validating generated code
CValidator	Validate generated code
CPair
CWatchdogInstance	Instance of a watchdog
Pgraph	Copyright (c) 2020, The University of California at Berkeley
CConnectionGraph	This implements a special graph that I call a ConnectionGraph
CDirectedGraph	Directed graph that maps nodes to its upstream and downstream neighbors
CGraph	Root interface for graph implementations
CInstantiationGraph	A graph with vertices that are Reactors (not ReactorInstances) and edges that denote dependencies between them
CNodeAnnotation	Note annotations used in Tarjan's algorithm for finding strongly connected components
CNodeAnnotations	Maps a node in the graph to its annotation
CPrecedenceGraph	Elaboration of DirectedGraph that is capable of identifying strongly connected components and topologically sorting its nodes
Pide
CLFIdeModule	Use this class to register ide components
CLFIdeSetup	Initialization support for running Xtext languages as language servers
Pscoping
CLFGlobalScopeProvider	Global scope provider that limits access to only those files that were explicitly imported
CLFScopeProvider	This class contains custom scoping description
CLFScopeProviderImpl	This class enforces custom rules
CRefType	Enumerate of the kinds of references
Ptarget
Pproperty
Ptype
CArrayType	An array type of which the elements confirm to a given type
CBuildTypeType	Enumeration of supported platforms
CBuildType	Enumeration of Cmake build types
CClockSyncModeType
CClockSyncMode	Enumeration of clock synchronization modes
CCoordinationModeType	Enumeration of supported platforms
CCoordinationMode	Enumeration of coordination types
CDictionaryType	A dictionary type with a predefined set of possible keys and assignable types
CDictionaryElement	Interface for dictionary elements
CLoggingType
CLogLevel	Log levels in descending order of severity
COptionsType
CPlatformType	Enumeration of supported platforms
CPlatform
CPrimitiveType	Primitive types for target properties, each with a description used in error messages and predicate used for validating values
CSchedulerType
CScheduler	Supported schedulers
CStringDictionaryType	Dictionary type that allows for keys that will be interpreted as strings and string values
CTargetPropertyType	An interface for types associated with target properties
CUnionType	A type that can assume one of several types
CAuthProperty	Directive to allow including OpenSSL libraries and process HMAC authentication
CBooleanProperty
CBuildCommandsProperty	A list of custom build commands that replace the default build process of directly invoking a designated compiler
CBuildTypeProperty	Directive to specify the target build type such as 'Release' or 'Debug'
CCargoDependenciesProperty	Dependency specifications for Cargo
CCargoFeaturesProperty	Directive for specifying Cargo features of the generated program to enable
CClockSyncModeProperty	The mode of clock synchronization to be used in federated programs
CClockSyncOptionsProperty	Key-value pairs giving options for clock synchronization
CClockSyncOption	Clock synchronization options
CClockSyncOptions	Settings related to clock synchronization
CCmakeIncludeProperty	Directive to specify a cmake to be included by the generated build systems
CCmakeInitIncludeProperty	Directive to specify cmake initialize files to be included at the very beginning of the generated CMakeLists.txt
CCompileDefinitionsProperty	Additional (preprocessor) definitions to add to the compile command if appropriate
CCompilerProperty	The compiler to invoke, unless a build command has been specified
CCoordinationOptionsProperty	Key-value pairs giving options for clock synchronization
CCoordinationOption	Coordination options
CCoordinationOptions	Settings related to coordination of federated execution
CCoordinationProperty	The type of coordination used during the execution of a federated program
CDNETProperty	Target property turning on or off the DNET signal optimization
CDockerProperty	Directive to generate a Dockerfile
CDockerOption	Docker options
CExportDependencyGraphProperty	If true, the resulting binary will output a graph visualizing all reaction dependencies
CExternalRuntimePathProperty	Directive for specifying a path to an external runtime libray to link to instead of the default one
CFastProperty	If true, configure the execution environment such that it does not wait for physical time to match logical time
CFedSetupProperty	Directs the C or Python target to include the associated C file used for setting up federated execution before processing the first tag
CFileListProperty
CFilesProperty	Directive to stage particular files on the class path to be processed by the code generator
CKeepaliveProperty	If true, configure the execution environment to keep executing if there are no more events on the event queue
CLoggingProperty	Directive to specify the grain at which to report log messages during execution
CNoCompileProperty	If true, do not invoke the target compiler or build command
CNoRuntimeValidationProperty	If true, do not perform runtime validation
CNoSourceMappingProperty	Directive to instruct the code generator to not produce line directives
CPlatformProperty	Directive to specify the platform for cross code generation
CPlatformOption	Platform options
CPrintStatisticsProperty	If true, instruct the runtime to collect and print execution statistics
CProtobufsProperty	Directive for specifying .proto files that need to be compiled and their code included in the sources
CPythonVersionProperty	A specific Python version to use
CRos2DependenciesProperty	Directive to specify additional ROS2 packages that this LF program depends on
CRos2Property	If true, generate ROS2 specific code
CRuntimeVersionProperty	Directive for specifying a specific version of the reactor runtime library
CRustIncludeProperty	List of module files to link into the crate as top-level
CSchedulerProperty	Directive for specifying the use of a specific runtime scheduler
CSingleFileProjectProperty	Directive to specify that all code is generated in a single file
CSingleThreadedProperty	Directive to indicate whether the runtime should use multi-threading
CStringListProperty	Note: set implements an "append" semantics
CStringProperty
CTargetProperty	An abstract base class for target properties
CTimeOutProperty	The timeout to be observed during execution of the program
CTracePluginProperty	Property that provides an alternative tracing implementation
CTracingProperty	Directive to configure the runtime environment to perform tracing
CTracingOption	Tracing options
CTracingOptions	Settings related to tracing options
CVerifyProperty	If true, check the generated verification model
CWorkersProperty	The number of worker threads to deploy
CTarget	Enumeration of targets and their associated properties
CTargetConfig	A class for keeping the current target configuration
Ptests
Pcompiler
CEquivalenceUnitTests	Test the equivalence of LF programs
CFormattingUnitTests	Test the formatting of LF programs
CLinguaFrancaASTUtilsTest	Collection of unit tests on the ASTutils
CLinguaFrancaDependencyAnalysisTest	A collection of tests to ensure dependency analysis is done correctly
CLinguaFrancaParsingTest	Test harness for ensuring that grammar captures all corner cases
CLinguaFrancaScopingTest	Test harness for ensuring that cross-references are established correctly and reported when faulty
CLinguaFrancaValidationTest	Collection of unit tests to ensure validation is done correctly
CMixedRadixIntTest	Test the MixedRadixInt class
CPortInstanceTests	Test the PortInstance class
CRangeTests	Test the Range class
CRoundTripTests	Test the round trip of LF programs
CTargetConfigTests	Tests for checking that target properties adequately translate into the target configuration
Plsp
CErrorInserter	Insert problems into integration tests
CAlteredTest	An AlteredTest represents an altered version of what was a valid LF file
CBuilder	A builder for an error inserter
CLspTests	Test the code generator features that are required by the language server
CMockCancelIndicator	Mock the CancelIndicator interface for testing
CMockLanguageClient	A MockLanguageClient is a language client that should be used in language server tests
CMockReportProgress	Collect progress reports and check that they have the expected properties
Pruntime
CCArduinoTest	Collection of Arduino tests for the C target
CCCppTest	Collection of tests for the CCpp target
CCFlexPRETTest	Collection of tests for the FlexPRET target
CCPatmosTest	Collection of tests for the Patmos target
CCppRos2Test	Run C++ tests using the ROS2 platform
CCppTest	Collection of tests for the Cpp target
CCSchedulerTest	Collection of tests for the C schedulers
CCTest	Collection of tests for the C target
CCVerifierTest	Collection of tests for the C verifier
CCZephyrTest	Collection of Zephyr tests for the C target
CPythonTest	Collection of tests for the Python target
CRustTest	Collection of tests for the Rust target
CTypeScriptTest	Collection of tests for the TypeScript target
Pserialization
CSerializationTest	Collection of tests for the serialization
Putil
CStringUtilTest	Test StringUtil functions
CConfigurators	Configuration procedures for TestBase methods
CConfigurator	Function to adapts a given target configuration
CLfInjectedTestBase	Base class for test classes that can use com.google.inject.Inject annotations to provide dependencies
CLFInjectorProvider	Note: this is a copy of a file generated by XText
CLFParsingTest	Test the parsing of LF programs
CLfParsingTestHelper	Utility to parse LF classes
CLFTest	Information about an indexed Lingua Franca test program
CExecutionLogger	Inner class for capturing streams during execution of a test, capable of recording output streams up until the moment that a test is interrupted upon timing out
CResult	Enumeration of test outcomes
CRunSingleTest	Execute a single test case
CRuntimeTest	A collection of JUnit tests to perform on a given set of targets
CTestBase	Base class for test classes that define tests that parse and build LF files from the TestRegistry
CMessage	A collection messages often used throughout the test package
CTestLevel	An enumeration of test levels
CTestError	Indicator for an error during test execution
CTestRegistry	A registry to retrieve tests from, organized by target and category
CTestCategory	Enumeration of test categories, used to map tests to categories
CTestMap
CTransformers	Transformers for test cases
CTransformer	Function to adapts a given resource
Putil
CArduinoUtil	Utilities for Building using Arduino CLI
CAverager	Average asynchronously reported numbers and do something with them
CCollectionUtil	Utilities to manipulate collections
CFileUtil	Utilities for file operations
CFlexPRETUtil	Utilities for FlexPRET
CImportUtil	Utility class for handling package-related URIs in the context of LF (Lingua Franca) libraries
CIteratorUtil	A utility class for Iterator
CLFCommand	An abstraction for an external command
CStringUtil	Utilities to manipulate strings
CTargetResourceNotFoundException	Exception thrown when a required resource could not be found on the classpath or is an empty directory
Pvalidation
CAttributeSpec	Specification of the structure of an attribute annotation
CAttrParamType	The type of attribute parameters currently supported
CBaseLFValidator
CValidatorStateAccess	Provides convenient access to the inner state of the validator
CLFNamesAreUniqueValidationHelper
CLFValidator	Custom validation checks for Lingua Franca programs
CValidatorMessageReporter	This class translates messages reported via the ErrorReporrter interface to the interface of a given ValidationMessageAcceptor
CAttributeUtils	A helper class for processing attributes in the AST
CDefaultMessageReporter	Simple implementation of the ErrorReport interface that simply prints to standard out
CFileConfig	Base class that governs the interactions between code generators and the file system
CInferredType	A helper class that represents an inferred type
CLFResourceDescriptionStrategy	Resource description strategy designed to limit global scope to only those files that were explicitly imported
CLFResourceProvider	Class that provides access to a resource set
CLFRuntimeModule	Binds services that are available both when running LFC standalone, and when running within the IDE
CLFStandaloneSetup	Initialization support for running Xtext languages without Equinox extension registry
CLFSyntaxErrorMessageProvider	Custom error message provider that intercepts syntax errors
CLocalStrings	Static class for managing strings
CMainConflictChecker	Class that (upon instantiation) determines whether there are any conflicting main reactors in the current package
CPackageVisitor	Extension of a SimpleFileVisitor that adds entries to the conflicts list in the outer class
CMessageReporter	Interface for reporting messages like errors or info
CStage2	Interface to report a message with a specific severity
CMessageReporterBase	Base implementation of the MessageReporter interface
CModelInfo	A helper class for analyzing the AST
CTimeUnit	A unit of time for a TimeValue
CTimeValue	Represents an amount of time (a duration)