All Classes and Interfaces
Class
Description
PathElement class that handles keys with invalid input: '&' values, like input: "photos-invalid input: '&'(1,1)""
It breaks down the string into a series of String or Reference tokens, that can be used to
1) match input like "photos-5" where "invalid input: '&'(1,1)" evaluated to 5
This class parses the Jolt invalid input: '&' syntax into useful programmatic constructs.
Subclass of Diffy that does not care about JSON Array order.
TraversalStep that expects to handle List objects.
Subclass of ArrayTraversalStep that does not care about array index numbers.
All "References" extend this class and support three level of syntactic sugar
Example with the AmpReference
1 "invalid input: '&'"
2 "invalid input: '&'0"
3 "invalid input: '&'(0,0)"
all three mean the same thing.
BaseSpec interface that provide a way to get its own pathElement and an apply(...)
method to process the spec using input, output and context
CardinalitySpec that has children, which it builds and then manages during Transforms.
Leaf level CardinalitySpec object.
A Spec Object represents a single line from the JSON Cardinality Spec.
The CardinalityTransform changes the cardinality of input JSON data elements.
Chainr is the JOLT mechanism for chaining
JoltTransforms together.Adapt "normal" Transforms to look like ContextualTransforms, so that
Chainr can just maintain a single list of "JoltTransforms" to run.
Helper class that encapsulates the information one of the individual transform entries in
the Chainr spec's list.
A factory class with various static methods that return instances of Chainr.
Interface to allow the guts of the Transform class loading logic to be swapped out.
Helper class that encapsulates the Chainr spec's list.
This Comparator is used for determining the execution order of childSpecs.apply(...)
Argument Map of Class: integer is used to determine precedence
Interface for Jolt Transforms that can incorporate context information along with the
source input JSON.
From the spec we need to guess the DataType of the incoming input
This is useful for,
a) in cases where the spec suggested a list but input was map
and vice versa, where we can just skip processing instead of
throwing random array/map errors
b) in case where the input is actually null and we need to create
appropriate data structure and then apply spec logic
Note: By design jolt does not stop processing on bad input data
List type that records maxIndex from spec, and uses that to expand a source (list) properly
MAP type class
Runtime type
Loads classes via Java Reflection APIs.
Defaultr is a kind of JOLT transform that applies default values in a non-destructive way.
JSON Diff tool that will walk two "JSON" objects simultaneously and identify mismatches.
Contains the unmatched fields from the Diffy operation.
The JoltCliProcessor for Diffy.
Deprecated.
Abstract class that provides rudimentary abstraction to quickly implement
a function that classifies first arg as special input and rest as regular
input.
Extends ArgDrivenConverter to provide rudimentary abstraction to quickly
implement a function that works on an input list|array
i.e.
Extends ArgDrivenConverter to provide rudimentary abstraction to quickly
implement a function that works on a single input
i.e.
Abstract class that processes var-args and calls two abstract methods
If its single list arg, or many args, calls applyList()
else calls applySingle()
Abstract class that provides rudimentary abstraction to quickly implement
a function that works on an List of input
i.e.
Abstract class that provides rudimentary abstraction to quickly implement
a function that works on an single value input
i.e.
squashNull is a special kind of null processing,the input is always a list or map as a singleton
This class allows Transforms specified in Chainr spec files to be loaded via Guice.
For use on the LHS, allows the user to specify an explicit string to write out.
TODO : Refactor the out to it's own class, as it really isn't a "Reference"
This is just a cheap hack at the moment.
An interface to describe a subcommand for the Jolt CLI Tool.
A utility class for the Jolt CLI tool.
Base Jolt Exception
Marker interface for all Jolt Transforms.
Handy utilities that do NOT depend on JsonUtil / Jackson live here
Utility methods for getting JSON content loaded from
the filesystem, the classpath, or in memory Strings.
Implementation of JsonUtil that allows the user to provide a configured
Jackson ObjectMapper.
Static method convenience wrappers for a JsonUtil configured with a minimal ObjectMapper.
Given an index at arg[0], and a list at arg[1] or args[1...N], return element at index of list or array
Given a list, return the first element
Given a list, return the last element
Given an arbitrary list of items, returns a new array of them in sorted state
Given an arbitrary number of arguments, return them as list
Meant to be an immutable PathElement from a Spec, and therefore shareable across
threads running multiple transforms using the same spec.
TraversalStep that expects to handle Map objects.
MatchedElement is the result of a "match" between a spec PathElement and some input data.
Base Templatr transform that to behave differently based on provided opMode
This variant of modifier only writes when the key/index is missing or the value is null
This variant of modifier only writes when the key/index is missing
This variant of modifier creates the key/index is missing,
and overwrites the value if present
Composite spec is non-leaf level spec that contains one or many child specs and processes
them based on a pre-determined execution strategy
Base Templatr spec
Size is a special snowflake and needs specific care
OpMode differentiates different flavors of Templatr
Templatr can fill in leaf values as required in spec from a specified context, self or a hardcoded
default value.
We cannot go away from this Optional to java 8 Optional because, this Optional gives as three states!
Where a value can an Object, a null (which is a valid json value) and absent,
which is not possible with Java 8 Optional.
An ordered composite spec denotes the spec will have Literal and Computed children that
must be Ordered Spec, which should be subject to sorting to before applying any of the
determined execution strategies!
This is not enforced directly, but these interface methods ensure the executionStrategy
gets the literal and computed children lists to process its exec strategy
The order is provided by a Mapinvalid input: '<'Class, int> and then ordering is achieved using a comparator
Reference is used by Shiftr when lookup up values from a WalkedPath (list of LiteralPathElements).
Static utility class that creates PathElement(s) given a string key from a json spec document
Combines a Traversr with the ability to evaluate References against a WalkedPath.
Reference is used by Shiftr when lookup up values from a WalkedPath (list of LiteralPathElements).
A tuple class that contains the data for one level of a
tree walk, aka a reference to the input for that level, and
the LiteralPathElement that was matched at that level.
Removr is a kind of JOLT transform that removes content from the input JSON.
Removr Spec that has children.
Spec for handling the leaf level of the Removr Transform.
Shiftr is a kind of JOLT transform that specifies where "data" from the input JSON should be placed in the
output JSON, aka how the input JSON/data should be shifted around to make the output JSON/data.
Spec that has children, which it builds and then manages during Transforms.
Leaf level Spec object.
A Spec Object represents a single line from the JSON Shiftr Spec.
Traverser that does not overwrite data.
Shiftr Specific version of a PathEvaluatingTraversal, where we supply a
ShiftrTraversr.
Utility class for use in custom Transforms.
Simple Traversr that
1 Does overwrite sets at the leaf level
2 Will create intermediate container objects only on SET operations
The JoltCliProcessor for Sortr.
Recursively sorts all maps within a JSON object into new sorted LinkedHashMaps so that serialized
representations are deterministic.
Standard alphabetical sort, with a special case for keys beginning with "~".
Factory class that provides a factory method create(...) that takes itself
as argument to specify how to handle child specs
Marker interface for Jolt Transforms that are based off a "spec".
Exception thrown by JOLT SpecTransforms during initialization.
Static utility methods for handling specStrings such that we can process them into
usable formats for further processing into PathElement objects
PathElement for the lone "*" wildcard.
PathElement for the a double "*" wildcard such as tag-*-*.
Marker interface for PathElements that contain the "*" wildcard.
Non-greedy * based Path Element.
PathElement for the a single "*" wildcard such as tag-*.
This class mimics the behavior of apache StringTools, except that it works on CharSequence instead of String
Also, with this, jolt-core can finally be free of apache-common dependency
The JoltCliProcessor for Chainr.
Exception thrown by JOLT transforms.
This PathElement is used by Shiftr to Transpose data.
The TransposeReader uses a PathEvaluatingTraversal with a SimpleTraversr.
Builds Traversal based on specific implementation of build(String path)
i.e.
A step in a JSON tree traversal.
The three things you can do with a Traversal.
Traversr allows you to walk JSON tree structures of data, and to GET and SET operations.
DataStructure used by a SpecTransform during it's parallel tree walk.