All Classes and Interfaces
Class
Description
Stores state during row-reduction as part of a
RealizedAggregateExpression.A
RiskscapeFunction sub-interface for a function that can be applied across many Tuples as part of a
RealizedAggregateExpression.Adapts an
AggregationFunction so that it can be called in a standard RealizedExpression.An 'ancestor rule' is used when comparing two types to decide whether they have a common ancestor.
The result of computing an ancestor for two types.
Wrapper around
Function to avoid nasty generics all over the shopList version of
AncestorTypeHelper interface that can make your code more succinct when producing Ansi text for display
A more convenient print stream API to use for printing things out to the console, supporting ANSI styling if the
underlying terminal supports it and fluid use (e.g.
The simplest type, which offers zero type checking
Factory for producing problems that involve arguments - either to
a function or a pipeline step.
AST base type plus subtypes for type expressions
A type that needs arguments given to it to be created, like a struct
has an identier and an argument list.
A constant, literal value, like a piece of text or a number
A map like structure where keys are symbols and the values are types or constants
A symbol is like an identifier - a string without quotes, a standalone
token.
Wraps a list of nodes so that it conforms to the AST interface
A abstract
ExpressionVisitor for converting expressions in a narrowly defined way.The base Model2 implementation.
Base class for
Resources.Convenience
RiskscapeFunction for adding metadata to a java BinaryOperator
function, specifically meant for a riskscape language BinaryOperationConvenience for adding
RiskscapeFunction metadata to a java BiPredicate
functionMinimal interface for a class that can bind strings to objects according to
ParametersBookmarks point to some resource to be used for risk modeling.
A
BookmarkResolver can access the data that is being pointed to by a Bookmark.A set of parameter values that have been bound from a particular
ParameterSet.Data holder for things that come from build.properties
Uniquely represents a particular type within a
TypeSet by an id.Runnable-esque interface for commands that want to be executed
Marker interface for pluggable top level picocli command
A function for transforming a value from one RiskScape type to another
Realized interface for a functor that can arbitrarily transform one set of tuples in to another.
A set of characteristics a collector can have which allow the
PipelineExecutor to better optimise and
organize execution.Deprecated.
Deprecated.
A
Command may define one or more ArgGroups: a group of options, positional parameters or a mixture of the two.Deprecated.
Exception indicating that multiple named elements have incorrectly used the same name.
Exception indicating that multiple fields have been annotated with the same Option name.
Exception indicating a problem while invoking a command or subcommand.
Defines some exit codes used by picocli as default return values from the
execute
and executeHelpRequest methods.A collection of methods and inner classes that provide fine-grained control over the contents and layout of
the usage help message to display to end users when help is requested or invalid input values were specified.
Provides methods and inner classes to support using ANSI escape codes in usage help messages.
Defines the interface for an ANSI escape sequence.
A set of pre-defined ANSI escape code styles and colors, and a set of convenience methods for parsing
text with embedded markup style names, as well as convenience methods for converting
styles to strings with embedded escape codes.
All usage help message are generated with a color scheme that assigns certain styles and colors to common
parts of a usage message: the command name, options, positional parameters and option parameters.
Builder class to create
ColorScheme instances.Policy for handling text that is longer than the column width:
span multiple columns, wrap to the next row, or simply truncate the portion that doesn't fit.
When customizing online help for
Option details, a custom IOptionRenderer can be
used to create textual representation of an Option in a tabular format: one or more rows, each containing
one or more columns.When customizing online help for positional parameters details, a custom
IParameterRenderer
can be used to create textual representation of a Parameters field in a tabular format: one or more rows,
each containing one or more columns.When customizing online usage help for an option parameter or a positional parameter, a custom
IParamLabelRenderer can be used to render the parameter name or label to a String.Use a Layout to format usage help text for options and parameters in tabular format.
Helper class to index positions in a
Help.TextTable.Controls the visibility of certain aspects of the usage help message.
Help command that can be installed as a subcommand on all application commands.
Provides default value for a command.
Deprecated.
Deprecated.
Classes implementing this interface know how to handle Exceptions that occurred while executing the
Runnable, Callable or Method user object of the command.Implementations are responsible for "executing" the user input and returning an exit code.
Interface that provides the appropriate exit code that will be returned from the
execute
method for an exception that occurred during parsing or while invoking the command's Runnable, Callable, or Method.@Command-annotated classes can implement this interface to specify an exit code that will be returned
from the execute method when the command is successfully invoked.Factory for instantiating classes that are registered declaratively with annotation attributes, like
CommandLine.Command.subcommands(), CommandLine.Option.converter(), CommandLine.Parameters.converter() and CommandLine.Command.versionProvider().Deprecated.
use
CommandLine.IHelpCommandInitializable2 insteadHelp commands that provide usage help for other commands can implement this interface to be initialized with the information they need.
Creates the
CommandLine.Help instance used to render the usage help message.Renders a section of the usage help message.
Determines the option name transformation of negatable boolean options.
Exception indicating a problem during
CommandLine initialization.Options or positional parameters can be assigned a
IParameterConsumer that implements
custom logic to process the parameters for this option or this position.Classes implementing this interface know how to handle
ParameterExceptions (usually from invalid user input).Deprecated.
Use
CommandLine.IExecutionStrategy instead.Deprecated.
use
CommandLine.IExecutionStrategy instead, see CommandLine.execute(String...)Provides version information for a command.
Exception indicating that more values were specified for an option or parameter than its
arity allows.Exception indicating that a required parameter was not specified.
Exception indicating that an annotated field had a type for which no
CommandLine.ITypeConverter was
registered.This class provides a namespace for classes and interfaces that model concepts and attributes of command line interfaces in picocli.
The
ArgGroupSpec class models a group of arguments (options, positional parameters or a mixture of the two).Builder responsible for creating valid
ArgGroupSpec objects.Models the shared attributes of
CommandLine.Model.OptionSpec and CommandLine.Model.PositionalParamSpec.The
CommandSpec class models a command specification, including the options, positional parameters and subcommands
supported by the command, as well as attributes for the version help message and the usage help message of the command.Internal interface to allow annotation processors to construct a command model at compile time.
Customizable getter for obtaining the current value of an option or positional parameter.
The scope of a binding is the context where the current value should be gotten from or set to.
Customizable setter for modifying the value of an option or positional parameter.
Encapculates type information for an option or parameter to make this information available both at runtime
and at compile time (when
Class values are not available).Utility class for getting resource bundle strings.
Command method parameter, similar to java.lang.reflect.Parameter (not available before Java 8).
The
OptionSpec class models aspects of a named option of a command, including whether
it is required or optional, the option parameters supported (or required) by the option,
and attributes for the usage help message describing the option.Builder responsible for creating valid
OptionSpec objects.Models parser configuration specification.
The
PositionalParamSpec class models aspects of a positional parameter of a command, including whether
it is required or optional, and attributes for the usage help message describing the positional parameter.Builder responsible for creating valid
PositionalParamSpec objects.This class allows applications to specify a custom binding that will be invoked for unmatched arguments.
Models the usage help message specification and can be used to customize the usage help message.
Exception indicating that the user input included multiple arguments from a mutually exclusive group.
Exception indicating that an option for a single-value option field has been specified multiple times on the command line.
Exception indicating something went wrong while parsing command line options.
Exception indicating that there was a gap in the indices of the fields annotated with
CommandLine.Parameters.Encapsulates the result of parsing an array of command line arguments.
Builds immutable
ParseResult instances.A group's multiplicity specifies how many matches of a group may
appear on the command line.
Provides information about an
CommandLine.ArgGroup that was matched on the command line.Base class of all exceptions thrown by
picocli.CommandLine.IDefaultValueProvider implementation that loads default values for command line
options and positional parameters from a properties file or Properties object.Describes the number of parameters required and accepted by an option or a positional parameter.
A regular expression-based option name transformation for negatable options.
Builder for creating
RegexTransformer objects.Command line execution strategy that prints help if requested, and otherwise executes the top-level command and
all subcommands as
Runnable, Callable or Method.Command line execution strategy that prints help if requested, and otherwise executes the top-level
Runnable or Callable command.Command line execution strategy that prints help if requested, and otherwise executes the most specific
Runnable or Callable subcommand.Fields annotated with
@Spec will be initialized with the CommandSpec for the command the field is part of.Exception thrown by
CommandLine.ITypeConverter implementations to indicate a String could not be converted.Fields annotated with
@Unmatched will be initialized with the list of unmatched command line arguments, if any.Exception indicating that a command line argument could not be mapped to any of the fields annotated with
CommandLine.Option or CommandLine.Parameters.Functional interface that redeclares
TypeConstructor.construct(TypeBuilder, AST.ComplexType)Used to represent a parsing operation that's conditional on a sequence of token possibilities.
Simple interface for raw application configuration values grouped in to sections, a la ini files, but abstracted a
little.
A named collection of String key value pairs.
A RiskscapeFunction that always returns the same value
Functional interface for a factory that wants to register an object to an
IdentifiedCollection
without completely creating it.Useful base class for features that just return a new instance of something of a particular type
An interface for
Types that are containers for other types, e.g.Two
ContainingTypes of the same type (e.g.Represents a
TypedCoverage using Riskscape's type system.Thrown from
ResourceFactory.create(CreateRequest) and friends when something goes wrong with storing some
dataA sort of transaction handle for saving resources to allow various housekeeping to be applied by various protocols
that allow storage.
Parameters for creating a resource via the
ResourceFactoryA unique/one-off custom code to use as a Problem's code.
Permissive Decimal type that will convert any
Number in to
a BigDecimal via Number.doubleValue().Implements a simple single-threaded collection of results from a Collector
A special case of a list type, which is always empty.
A relation that has no values, just a type.
An Engine is the central part of the application that offers core services for doing data processing.
An extension of the Engine interface with extra methods that are only safe to call during engine bootstrapping
Bit of code that adds something to an engine instance when it's created.
An engine collection allows new IdentifiedCollections to be plugged in, accessible via
IdentifiedLocator.getCollection(Class)Interface for commands to implement if they want access to a riskscape engine during execution.
Riskscape type that maps a set of numbers to a set of well-known strings.
An equivalence rule allows type-safe coercion to be applied to the Riskscape Expression language in a pluggable way.
Various bits associated with the realization and execution of a pipeline
Various options that apply to
PipelineExecutor#execute(RealizedPipeline, ExecutionOptions)Returned from
PipelineExecutor#execute(RealizedPipeline, ExecutionOptions).Return this from a
ChildCommand command to indicate special exit instructions from the programThrow when there is some issue with the command that deserves an error
message to the user along with potentially a non-zero exit
An as yet Unrealized expression AST.
A
ExpressionVisitor for converting expressions in some way.Builds a Riskscape Language Expression AST from a string.
Factory for creating problems involving an expression
Produces realized (and evaluation-ready) expressions from an AST and an input type as scope.
Standard set of problem codes for describing problems during expression realization
An ExtensionPoint is an official advertised place that allows a
Plugin to advertise a PluginFeature
SPI and a place where implementing features should be registered by the plugin system during startup.Thrown from an
IdentifiedCollection when an object is looked up that couldn't (or wasn't) successfully
created.Factory for producing problems that involve a specific file, e.g.
A realized
FlatProjection.A Format represents a file format (or other) used for data coming in and out of RiskScape.
Format characteristics are here to guide the various bits of code that use them to be able to use them generically
without prior knowledge of them specifically.
Context containing things that may be useful to
RiskscapeFunctions being instantiated from
external sources.Defines a framework for building functions, e.g.
Holds the common details about a RiskScape function, such as its argument-types and return-type.
Used for realizing
FunctionCall expressions to produce a RiskscapeFunction that can be used during
execution of RealizedExpression.evaluate(Object).Type information for a first-class function being stored in a tuple (as an
UntypedFunction)General purpose problems that can appear in many parts of the system.
Riskscape Type that represents geometry, e.g.
An enumeration of the main Geometry type 'families' we support in RiskScape, ranked in terms of their
lowest-common-denominator-y-ness when intersecting each other, e.g.
A utility for automatically fixing invalid
Geometry.A base implementation.
Thrown when a
Geometry is found to be invalid.Problems relating to Geometry operations, errors, etc
Thrown when a
Geometry is not able to to re-projected to another CoordinateReferenceSystem.Rule allow
Geometry sub-types to be assigned to Types.GEOMETRY.Enum to control if geometries should checked for validity and what to do if they are not
Base for a
Type that wraps Types.GEOMETRY to make it a more specific geometry
sub-type.Feature interface for plugins to indicate they have i18n message bundles on their classpath.
Interface that may be added to
Realized implementations should they have specific metrics.Object that as an identifier.
A collection of
Identified objects.Convenience class for any
IdentifiedCollections that want to work from an in-memory set of objects.Thrown by an
IdentifiedCollection when there was some issue with adding or getting an object from the
collection.A
RiskscapeFunction that is identified by its Identified.getId().An IdentifiedLocator is a service locator style API that allows an IdentifiedCollection to be looked up by the class
the collection contains, e.g.
Wraps a type to include an identifier and a
TypeSet to link it back
to some managed and identified set of types among a set.Problems relating to one of the user's input data sources.
Permissive Integer type that will convert any
Number in to
an long integer via Number.longValue().Allows assignment of integers to floating point - considered a downcast, as an integer value can represented 'enough'
by a floating point rule.
Functional interface for an interrupt handler.
Thrown when a method expects a set of bound parameters that match a particular set of defined parameters
but they don't match.
Thrown when an invalid tuple (row) of input data is encountered, i.e.
Can be thrown by commands when there is some higher level problem with they way a command has been used
that could be solved if the user RTFM.
Immutable prototype-builder implementation of
IdentifiedFunction
TODO given the use of this an all sorts of other implementations, the name of this needs to change to be more like
'BaseFunction' or 'ImmutableFunction'This rule stops variance calculation when the java types are not compatible
Interface for classes that can join a relation on to another relation, tuple
at a time.
Specifies what kind of join this is
A lambda expression in the RiskScape language is a self-contained expression that can be applied to a list of
arguments.
Represents a lambda expression in an unrealized function's type signature.
Meta-class object for token type enumeration.
General exception thrown during lexing
A list declarations yields a list of whatever is expressed within it, e.g.
A LookupTable is a data source that allows some value to be looked up based on a key.
Represents an instance of a
LookupTableA variation on Joiner that works by joining individual values from the lhs (left-hand side) to an indexed
set of rhs (right-hand side) values.
Thrown by a ExpressionParser when we got an unexpected token, indicating that
the expression must be malformed.
metadata from the execution of a pipeline
A MessageFactory allows i18n messages to be declared and looked up from a MessageSource using a declarative dsl-ish
technique.
Interface for objects that are suitable for message resolution in a
MessageSource.High level interface in to RiskScape's i18n subsystem.
Strategy interface for resolving messages, with support for the parameterization and internationalization
of such messages.
Convenience class for dealing with the basic metadata-related aspects of a function,
i.e.
Subclass of
ExpressionVisitor that does a traversal through the AST, without modifying anything.Represents the new style of Riskscape model.
Defines a framework for building models, e.g.
A
Step that uses another pipeline as part of its processing.Used to track the construction state of this step, as we have to do a bit of collaboration across components to
successfully build and validate pipeline steps that nest a child pipeline.
Thrown from BindingContext when a binding fails because no
ParameterBinder is available to bind with the
given from and toThrown when a tuple is queried for a member that does not exist.
Thrown when
IdentifiedCollection.get(String) does not find an object with the given id.Throws by
TypeIOBuilders when a TypeIO object couldn't be constructed - typically because there
is no support for reading/writing a particular type.Accepts null/nothing being passed to a Nullable target.
Wraps another type to allow values to be null.
Allows two types to be ancestors by making the ancestor type nullable if either of the descendant types are also
nullable
Allows equivalence to be determined by the types inside a nullable
Passes variance test on to the contained type of a nullable if the target, or the target and source, are nullable.
A
RiskscapeFunction that wraps another one to short-circuit the target function to return null if any of the
args are null.A converting rule that flattens any number types to floating to allow them to be ancestors
Thrown when an attempt is made to add an object to an
IdentifiedCollection, but the collection
already has an object with the same id.Allows plugins to define custom 'toString' rules for generating a localized string representation of an object, in
addition to the defaults.
Wraps a type adding some extra unit metadata, e.g.
Used for Realizing
BinaryOperations in to RealizedExpressions that can be used to evaluate an
expressionVarious utilities for interacting with the OS
Signals that an
IdentifiedFunction supports different combinations of types.General purpose pair type
Parameters are the inputs and toggles that ultimately control how Riskscape works.
Interface for a class that can convert a string in to an object of a particular type
Thrown by
ParameterBinders when a value can not be converted to the desired type for some reason.Represents an expected property or 'trait' that the parameter should have,
especially in terms of how a UI user should specify the parameter value.
An
ExpressionVisitor that rewrites an expression by replacing any parameters it has found with substitutions
from the visitor's map of replacements.A set of
Parameter objects that are grouped together, typically as a set of required inputs for something
that a user adds to their project.Contains the aspects of a parameter that the user can customize themselves.
A parameter can have a set of pre-defined choices, i.e.
Represents an unresolved expression within a larger expression.
Base exception thrown when converting a sequence of tokens from a
Lexer in to an abstract syntax tree.A user-configurable data processing pipeline for performing hazard analysis.
Thrown when a cycle is detected in a pipeline
AST for a pipeline declaration - the root of the AST.
Simple value holder for the results of finding a step via the
PipelineDeclaration.find(BiPredicate) method.Thrown by
Pipeline when adding edges or steps to a pipeline.Bits and pieces that are all relevant to the execution of a specific pipeline (aka A job) as it is being executed
(or prepared for execution) as per the users wishes.
Some basic metadata that can be associated with a pipeline
A container for storing outputs from a pipeline run.
Contains user specified options to use when saving results from a pipeline execution.
Defines an output store that is able to store the results of pipeline execution, aka a pipeline job.
Factory for producing problems that involve pipelines or pipeline steps.
A Riskscape Plugin.
Contains meta data and standard methods for integrating a plugin's code base in to RiskScape
Marker interface for any code that implements a feature that should be registered with an
ExtensionPointPluginRuntimeException are thrown when the plugin system fails to initialize or start a pluginSpi for plugins that can parse prj files.
Class used for describing errors and other issues with user defined input.
Interface for enums that describe a set of
ProblemCodes - see StandardCodes for an example.Thrown from
ResultOrProblems.getOrThrow() as an alternative to using functional style flow control in your
code with ResultOrProblems.A function call that will either return an object or throw a
ProblemException.Indicates that a particular interface is solely used for generating
Problems.Works as a Proxy for a given
ProblemFactoryA convenient placeholder when constructing a
Problem's args.Helper for generating Problem objects.
A place for problems to fall down when the user should know about them, but they're not going to stop execution.
Contains Riskscape project resources, such as:
- types
- functions
- models
- bookmarks
A projection is a view of some underlying relation, where each tuple is potentially transformed.
Realized
Projection of one Struct to another.Property access represents an indexing of the scope or another expression, e.g.
A global source of randomness for a riskscape process to aid reproducability of results
Helper functions for generating random numbers or sampling from random
distributions.
Marker interface to say that the underlying java
representation of a type is
ComparableSpecial case ExitException that is thrown from
Terminal#readline() when a user ctrl-cs when entering text.An interface for functions to indicate that they can be realized for a particular set of input arguments in a
riskscape language expression.
Access to contextual bits and pieces in which realization is going to happen - this metadata will also be
relevant for the eventual execution of an
Expression and can be passed through to any
RealizedExpressions and their dependents that result from realization.Marker interface for other interfaces that can be returned from a
Step.realize(RealizationInput).An expression that can be evaluated across many inputs to eventually yield a single 'scalar' result
Represents an Expression that has been realized against a specific RiskScape type.
A
Step that has been realized, such that it has produced valid output.Type that adds
CoordinateReferenceSystem and an optional bounds to another type.Allows two Referenced geometry types to be ancestors, maintaining their
Referenced wrapping type so long as
they are in the same CRS.Represents a
Relation using Riskscape's type system.Returned from
Messages.renderProblem(Problem, java.util.Locale) to translate a problem while maintaining its
tree structure.Used for customizing the output of toString
Links a
Bookmark to a BookmarkResolver in order to access the useful data.Represents a file type resource in a way that allows where the resource is from to be decoupled from how it
is accessed.
A resource that can not be opened but is still useful for identifying some content.
An object able to load certain kinds of
Resources.Exception indicating a problem of some kind with the loading a
Resource.A glorified
Predicate with support for riskscape type safety checks and geotools Filter
representation.A
Restriction that has been built and verified to work with a given type.Thrown when
ResultOrProblems.get() is called and there is no result.An optional-esque that contains the result of some result-yielding operation where it may have had problems
which might have stopped it from producing a result.
Root exception that all exceptions from Riskscape engine code should extend.
General interface for any kind of function that accepts and returns riskscape types values.
Can be thrown by engine code to say there was some underlying IO issue that caused
data processing to fail.
Interface for writing out riskscape values
Basic list type that can convert various arrays and list types to the required type
Rule that passes when the source and target have the same
Type object.A
LambdaType that also includes the scope.Loosely termed thing that is typically used to gain privileged access to something else.
A thing that can build a particular type of secret from some well-known parameters
A 'select all' expression is an asterisk by itself (i.e.
An optional interface for an object that can describe itself in terms of RiskScape types.
Represents the simplest single-value type, e.g.
Function interface that redeclares
TypeConstructor.construct(TypeBuilder, AST.Symbol)Allows a singular specific geometry type (LINE, POINT, POLYGON) to be coerced to a multi form of
the same type.
Special case
TupleIterator for a single Tuple.Allows assignment between structs and simple values if the struct has a single member who's type matches the single
value.
Accepts output tuples from a pipeline step, possibly for saving results, but also potentially for processing them
before having them emerge somewhere else in the pipeline.
Defines options that are useful when constructing a
SinkDefines an sort by, consisting of an
Expression to obtain a comparable value and SortBy.Direction.Optional meta data for a
RelationSRIDSet is the "central authority" in riskscape for managing CoordinateReferenceSystems.
A pre-defined set of common types of problems.
AST for a list of
StepDeclarations that are chained together.AST for a single step.
Defines a step.
Slightly-over-engineered way of determining an implicit name, if possible, for a step definition.
Reference to a step that should have been declared previously.
Permissive struct-like type that allows a c-like struct (like a java class with only fields) to be declared
with members being other riskscape types.
Builder class for constructing struct types with a fluid api
A command that wants access to a
TerminalA plain old string.
Functional interface that replaces using
Pattern for sometimes easier, more understandable and more
flexible pattern matching during lexingInterface for enum members used by
LexerTokens used by
ExpressionParserRepresents the current context of the translation, i.e.
Options for error suppression/checking when using the
Tuple.coerce(Struct, Map) methodBrings together the
AutoCloseable and Iterator interface fo Iterators that come from
Relations, so that iterators can clean up any resources they are derived from.Simple interface for something that reads
Tuples from an underlying stream of dataGeneric, and slightly wip, interface for creating
TupleReaders and TupleWritersStripped back interface for writing tuples out, presumably to some sort of underlying output stream.
The root interface for Riskscape's type system.
Thrown when a particular argument received by a
TypeConstructor isn't valid for the typeInterface for constructing riskscape
Type objects from a riskscape type-expression, e.g.A provider of
Type values backed by a Coverage.An empty coverage, useful for testing, stubs, or proxy implementations
Meta-class for riskscape types that allows types to be plugged in to the riskscape engine.
java.nio based interface for reading and writing riskscape-typed objects from and to a
ByteBuffer.Builder/Factory interface for a type that can construct
TypeIO objects for arbitrary typesFunctional interface for constructing a
TypeIO object from a type.Minimal
TypeSet interface for use when only testing of types is required/allowed.Singleton instances of SimpleValued types to avoid needless construction
TODO maybe make the constructors package level to hammer it home?
Type safety wrapper around an
AncestorRule to avoid having to instanceof test the typesA Visitor interface for descending through an arbitrary type 'tree' - the other half of
Type.visit(TypeVisitor, Object).Deprecated.
Move over to APIs that use
NoBindingAvailableExceptionThrown when a null value was unexpectedly encountered in the input data.
Thrown by a Parser when we got a token we weren't expecting
Thrown when an object is asked for by id from the engine, but the engine
doesn't know a function by that id.
Thrown by
SRIDSet when the SRIDSet.get(int) method does not have a CoordinateReferenceSystem
by that idThrown by a
TypeBuilder when a AST.Symbol or AST.ComplexType is encountered that is not
known to
the type builder, e.g.A minimal
RiskscapeFunction interface, which exists for two reasons: 1) store a reference
to a first-class function in a tuple 2) a minimal functional interface for use with creating minimal riskscape
functions without having to implement RiskscapeFunction.Represents any java object that has been coerced to the associated type.
Represents the result of a
TypeSet.testVariance(nz.org.riskscape.engine.types.Type,nz.org.riskscape.engine.types.Type)Variance rules allow the type system to advise whether one type's values can be directly assigned to another without
having to alter the receiving type (and consequently value).
Type that limits value to be within a specified range.
Can be one of the given values.
Wrapping type that stores extra metadata along with a given type.
'peels' the onion of two wrapped types to find the common kernel.
Wrapping types add extra restrictions or metadata to a type that narrows that type.
Will allow assignment if the source type is more specific than the target type.
Functional interface for something that is able to create a
RiskscapeWriter.
CommandLine.execute(String...)