All Classes and Interfaces
Class
Description
Writes typed riskscape
Values out to a new file.Does all the work for
DefaultExpressionRealizer.realizeAggregate(Type, Expression)Deprecated.
Deprecated.
Utility for swapping
Geometry coordinate order, typically so that it's in the right order for writing where
an output format demands a particular axis order.Convenience class with built in support for integer and floating point modes and everything in between
Base class for
ModelFrameworks - so far this is just a place for a convenient method for handling an
incomplete ParameterSet to live.Base class for DRYing up all the code common to most
RealizableFunctionsFactory for creating
Bookmarks from files in ini format.Utility allowing boolean yielding expressions to be realized against a
Struct type that may
not contain all referenced properties.Used to load minimal INI config settings, whilst the engine is still bootstrapping,
i.e.
Gets the bounding box (BBOX) as a
Geometry from a Referenced.Function to buffer (enlarge) a
Geometry.A plugin descriptor for code that wasn't dynamically loaded (and can also be used in some testing scenarios)
A RiskScape 'test' function that evaluates a simple (argument-less) lamba
expression with given scope/input.
Combines multiple ReadPageBuffers into one, for convenience
An
AggregationFunction that is composed of one or more child AggregationFunction.Returns a constant object of a constant type
Base class to build filter converters upon.
Provides utility functions useful to
TypedCoverage implementations.Very simple csv writer, to avoid the ceremony and geometry-required-ness of the geotools one.
TupleReader that uses
Type deserialization methods to read a tuple from an
InputStreamTupleWriter that uses Type.toBytes(DataOutputStream, Object) for serialization to an underlying
OutputStreamWrapper that maps a two-dimensional (x, y) grid to an underlying set of data.
Provides TypedCoverage that maps an underlying dataset to latitude and
longitude coordinates.
Various bits of dependency that might be required for parameter binding
Realizes riskscape language expressions in to reified/realized objects that can be evaluated.
Minimal interface for a set of
IdentifiedFunctions that can be looked up by an id.Helper to render
Problems for display to users, i.e.Core set of functions that work with the default types in RiskScape - should cover most of what ECQL does.
Factory of
Resources.Assigns a name to steps based on their step id and order in the AST
An
RiskscapeFunction that allows a discrete function to be defined.API For users to build their
DiscreteFunctionA member of the
DiscreteFunction.TupleStorage backed by a directory on the filesystem.Wraps a
DataInputStreamTupleReader to apply byte counting and buffering to a FileOutputStream.Wraps a
DataOutputStreamTupleWriter to write out to a buffered and byte counted FileOutputStream.Exception thrown when engine encounters unrecoverable problems.
Default implementation of a singleton for an engine instance.
A not-quite plugin for core SPIs and Features that get initialized like other plugin SPIs and Features, but without
the classloader malarkey
Step to enlarge (buffer) a geometry member.
Helper for handling translation of Enum values for user help, CLI display, etc.
Thrown by
RealizedExpression when RealizedExpression.evaluate(Object) failsUsed as a
Future for jobs queued up on the Scheduler.Build an
AggregationFunction based on a set of riskscape expressions that reduce the input into an
accumulator value, combine accumulated values (to support parallelism) and then emit a collected value.Wee builder to decrease chances of bugs due to mis-assigned constructor args.
JoinCondition based on a RealizedExpressionA map interface to a
SimpleFeature whichFeatureSourceBookmarkResolver<DS extends org.geotools.api.data.DataStore,BP extends RelationBookmarkParams>
Provides a basic framework for constructing a
FeatureSourceRelation from the various geotools APIsProvides a stream of
Tuples based on a SimpleFeatureSourceTODO start to pair back all of the support in here so that it lives in the resolvers - strip this back to just
local file support maybe
A
TupleIterator backed by a FeatureIterator.Adaptor that makes a
Filter available as an TypedExpression that will return
a boolean when evaluated.Validates a
Filter or an Expression against a Struct to check for potential problems when
it is evaluated against a Tuple of that type.Projects tuples where nested tuples are flattened in to a new attribute, according to a specific join character,
e.g:
Projects a tuple by modifying it's geometry in place to have a specific srid, as well as replacing the
SpatialMetadata that the relation produces to match.Binds a function id to function.
Thrown during a function call to a
RiskscapeFunctionWraps a
FunctionCall and provides conveniences for updating the function call arguments.Binder for
FunctionCallPrototype that allows binding by id only (e.g.Each
JavaFunction may have classes loaded from its own FunctionClassLoader.Deprecated.
A
RiskscapeWriter that writes in GeoJSON format as specified in RFC7926.Tweaks the display of some GeoTools geometry so that it's more user-friendly.
Gives relation-style access to a grid by iteration through the raster pixel-by-pixel
Can apply a
GridGeometry to a Geometry to be able to slice it up in to cellsThe 'sides' of each axis.
JoinIndexer implementation that builds an in-memory hash index of tuples when the
JoinCondition is an equality filter.ClassLoader for use with building
ResourceBundles that uses an explicit search path for finding resources
for use with ResourceBundleControl to control the order with which values from bundles over-write each other.IdentifiedObjectBuilder<T extends nz.org.riskscape.engine.Identified>
Builds an Identified RiskScape item (bookmark, type, model, etc) from an INI
file section.
IdentifiedObjectBuilder.Base<T extends nz.org.riskscape.engine.Identified>
Special case binder that sits at the end of the binders and will just return back what it's given if no binding
is necessary
Implementation of https://docs.geoserver.org/latest/en/user/filter/function_reference.html#control-functions
A
TypedCoverage that is backed by a Relation.Builds a user-defined function from an INI definition.
Builds a framework-based model from an INI definition.
Builds a user-defined parameter from an INI definition.
Can add
Types to a TypeSet via an ini file and the riskscape type expression dslProvides methods to parse INI files with defined settings
- multi section enabled allowing duplicate sections and keys
- escape new lines allowing values to span multiple lines
- set escape false, so Windows paths don't need excessive escaping.
Describes aspects of how the UI should present the parameter to the user,
i.e.
Creates an index of tuples using an underlying
STRtree, implementing a couple of standard routines for
querying the index for tuples, dealing with reprojection and other housekeeping concerns.Implementation of https://docs.geoserver.org/latest/en/user/filter/function_reference.html#comparison-functions
Can join a relation on to another relation, tuple at a time.
Base class that collaborates with the
DefaultJoiner to provide the rhs of a join, given the lhs.Cheap way of avoiding a full-on factory pattern thing - each Indexer implementation should offer a Constructor to
build an indexer from the given arguments.
Produces a stream of json formatted lines representing each tuple.
Stores a property that represents a key-value pair, e.g.
A
RiskscapeWriter that writes KML (Keyhole Markup Language)Groups together pipeline steps that can be processed in the same task.
Base class for an
AggregationFunction that needs to collect encountered items into a list
that the ListCollecting.ListProcessor can extract the aggregated result from.Provides a simple single-threaded work queue to let us work around geotool's thread-bound locks for accessing
shapefiles.
Converts a
LopsidedJoiner in to a FlatProjector so that a pipeline can parallelize the lhsJoins a single lhs value against a set of rhs values, emitting them if the join condition holds.
Riskscape implementation of a list mapping function.
Some general purpose mathematics functions using the
RiskscapeFunction interface for use within
the riskscape engine.A set of useful maths functions for use with risk modelling
A
Gauge returning a string indicating whether memory usage is within a certain band = a PoC to see whether
we can detect low memory situations reliableConsolidates a list of
TupleReaders to always return the min value first as per the Comparator.Defines what parameters a INI file function definition can accept, i.e.
MissingDependencyException will be thrown if a plugin dependency
cannot be found.AggregationFunction to find the mode(most observed value).A
TypedCoverage that will find the nearest match that is within maxDistance.An index that when queried will return the nearest neighbour should one exist within a max distance.
JoinIndexer that does nothing, so should always work, albeit slowlyPerforms geometry overlay operations on two geometries.
Base class for math functions that can be used as an
AggregationFunction and also called
directly with both single list argument (as an aggregating function) or with two numeric arguments.The
Scheduler works with Pages, which is simply a block of Tuples.Handles all the complicated logic of how many tuples should fit into a Page.
The main interface for passing buffers of Tuples see
core/ nz.org.riskscape.engine.Tuple between
WorkerTasks.Reads tuples from a buffer 'page'.
Takes a page of tuples as input and writes smaller pages as output.
Writes tuples to a buffer 'page'.
Like a
FeatureSourceRelation, useful for working with FeatureStores that are backed by WFS.Wraps a transformation chain to parallelize its execution
Takes pipelines in plain-text DSL form and slots them into the model
framework, so that they can be run the same way as any other model.
Helper class for dealing with
ParameterPropertys.Builds an
AST from a LexerCalculates percentiles using the nearest-rank method.
A
PercentileAggregationFunction that returns a single percentile.A
PercentileAggregationFunction that returns a single predefined percentile.Traverses a
PipelineDeclaration to produce a Pipeline.A slightly more specialized
ModelParameter that deals specifically with pipelines,
i.e.Each
Plugin has classes loaded from its own DefaultPluginClassLoader.The
PluginRepository is a registry of plugins.Simple point construction function, built for use with
RelationBookmarkResolver to allow CSV data to be
'geometerized' from points within the dataInitializes a Riskscape
Project for an Engine and list of Plugins.Geometry operation to return geometries in a
ProjectedCRS which makes measuring and other
geometry operations easier.org.geotools.data.wfs.internal.GetParser<org.geotools.api.feature.simple.SimpleFeature> for WFSFeatureReader that uses the
geotools PullParser to fetch Features out of a WFS GetFeature response.Represents the four relative locations of rectangles formed by bisecting another rectangle along the X and Y axis.
Used to randomly choose an item from a list.
Buffer that a
WorkerTask reads output from.Abstract
JoinIndexer for creating indexers that perform some kind of comparison with
a boolean yielding RealizedExpression.Alternative to CutGeometryByGridOp that builds a list of geometries that are intersected at a given grid size
by breaking a feature up recursively in order to 'throw away' as many useless large areas as possible in order to cut
down on the number of intersections required.
All the bits and pieces involved in the recursive quadding, plus ways of accessing it
Allows a
Relation to be treated like a List in a pipeline.Base class for a thing that returns relations from a bookmark.
Supports property renamings/transformations when applying a filter to a projected relation.
A function to re-project geometry to a
CoordinateReferenceSystem of the users choice.Extends Java's default
ResourceBundle.Control to:
* Assumes properties files are encoded in utf-8 instead of latin-1
* Support loading the same named file from different locations to take the super-set of values from all, but with
last-one-wins behavior, where last-one is the last resource identified by the classloader as having that name
* Disables fall-back locale behavior so that this can be handled in the message sourceA
ClassLoader for loading resources from the supplied URLs only.Deprecated.
we don't use these expressions any more
MessageSource implementation that will resolve messages:
- from many ResourceBundle baseNames
- will merge property files with the same base name across a classpath using MergedPropertiesResourceBundle
- will fallback through locales for values using built-in ResourceBundle parenting logicConstructor for a
SaveSinkSaves results out to supported formats, relative to some storage location
Function that will return a scaled version of the first argument by the scale factor in the
second argument.
The Scheduler oversees the execution of the pipeline tasks.
Executes a pipeline by breaking the steps down into tasks, and then using a
Scheduler to manage running the tasks in parallel where possible.
The result of calling
RealizedExpression.evaluate(Object) on a Lambda that has been
realized.Step that will transform flat input data into a more nested form.
Allows attributes to be replaced or added to the input via a set of arbitrary expressions against the input.
The Shapefile format does not support null values.
Writes typed riskscape
Values out to a new shapefile.A
RiskscapeWriter that talks to geotools's codecs to avoid the performance impact of using all the feature
source diffing code and index generation.Logic for writing dbf header based on java types, lifted from
ShapefileWriter for reuse by RiskScapeConverts a string to an
SortBy.Sorts output based on user configured
SortBy expressions.JoinIndexer implementation that attempts to build an in-memory spatial index of the tuples
for narrowing down the set of rhs tuples.A
TypedCoverage that is backed by a Relation.Access properties by path inside riskscape Tuples
Flattens nested
Structs to allow them to be written to data sources that don't support nested data
structures.Namer that produces a name that is taken from
Struct.StructMember.getKey() for each segment and
separated by a '.'.A
StructFlattener.Namer that will use the Struct.StructMember.getKey() from the last segment as the name.A Namer can provide a name for the given segments.
Access properties inside riskscape values using struct member lookups which gives consistent access times.
The TaskSpec defines the work for a step or series of steps in a pipeline.
Timer to get the mean duration over a series of events.
Abstract base class for sorting.
Accepts tuples, while providing a way to iterate over the tuples that were
received.
TODO commented out values are for consideration for #199, for now support skipping and validation.
Describes the type of value we expect for this parameter, i.e.
Projects from one type of tuple to another.
Takes tuples that potentially differ in type from two or more sources, and
reprojects the tuples to a common type
Thrown during realization when a $foo expression is encountered.
Binds strings to a
URI by parsing them with URI.create(String)Represents a function defined by the user in a script file (e.g.
A projection that detects any invalid
Geometry and throws InvalidTupleException should
an invalid geometry be found.Utility for producing a
GridCoverage2D from a Relation, adapted from some geotools code in an
unsupported moduleImplements
ExpressionVisitor and FilterVisitor with no-op methods.The Worker represents a thread that can run tasks.
A WorkerTask is based off a TaskSpec and is what actually carries out the
work for the pipeline step(s).
Buffer that a
WorkerTask writes output to.Riskscape implementation of a zip mapping function.
RiskscapeFunctionExpressionwhich itself is deprecated and scheduled for termination