Package com.neurosys.etl.common.transformers

Interface Summary

Interface	Description
BatchTransformer<R,T>	A definition marking an implementation that takes in a collection as a parameter for its Transformer as opposed to direct arguments.
CreateEntityTransformer<T>	Creates an Entity of type T from any input, including null
FunctionTransformer<T,R>	A Function and a Transformer One must override Transformer.transform(Object).
ValidationTransformer<T extends Throwable>	By default Transformer does not allow throwing of Throwable.

Class Summary

Class	Description
AbstractEntityToTupleTransformer<ENTITY,TUPLE>	Converts an Entity to a Tuple.
AbstractEntityTransformer<NODE,NODE_IDENTIFIER,ENTITY>	Boiler plate common methods for an EventAwareProcess, ModeAware Transformer Note: A NODE is the smallest aspect of an entity that is available for processing.
AbstractObjectToEntityTransformer<NODE,ENTITY>	Converts a Row/Tuple/Node to an Entity This Process is EventAwareProcess.
AbstractReverseTupleToEntityTransformer<ENTITY,TUPLE>	Sometimes its nice just to conveniently reverse a mapping process from INPUT to OUTPUT and maintain the same format so that the produced output can be consumed again as an INPUT. We are not talking about a chain here, but the output of this Transformer as an INPUT to its AbstractTupleToEntityTransformer back as an input.
AbstractReverseTupleToEntityTransformer.OverridableHashMap	A Map that can provide a Primary Map and an override where it maybe applicable based on the order of precedence mentioned in AbstractEntityToTupleTransformer.transform(Object)
AbstractTupleToEntityTransformer<TUPLE,CELL,ENTITY>	Converts a Tuple (abstract tuple as a concept) to an Entity
AsynchronousTransformer	Asynchronously forms off the transformation process in parallel; when it finishes it calls a #listener as a callback with the final output.
BitMaskTransformer	If a a Number is represented as a sequence of bits.
BitsToStringTransformer	Useful in converting an integer to its binary, Hex or octal form.
CaseTransformer	Converts Object to String (using toString()) and converts to lower case or upper case or camel case
CloneCollection	Clone a List and every element in it.
CollectionFilterSortTransformer	Apply a Filter/Predicate & Sorts on the original Collection
CollectionToMapSplitterTransformer	Take a Collection and convert it to a Map based on an CollectionToMapSplitterTransformer.identifier.
CollectionToStringTransformer	Convert a Collection to a String.
CollectionTransformer	Take a Collection, Array or Map and apply a nested Transformer to each element.
ConditionalTransformer	A Transformer that takes in input to decide which Transformer will finally execute the given input
ConstructEntityTransformer<T,R>	Given a parameter or List of params of Constructor for type ConstructEntityTransformer.required; produce the object of type
ContextExtractorTransformer	Some Transformation processes require context/Scope with various interdependencies during the transformation process.
ContextMapperTransformer	Some Transformation processes require context/Scope with various interdependencies during the transformation process.
ConvertBlankToNullTransformer	Convert all blankes to Null
DateTransformer	Take a String or Date and convert it to Date off the given DateTransformer.format
DecimalFormatter	Wraps DecimalFormat
DeDupeFilterTransformer	Ensure for a Collection all objects are unique.
DefaultCreateEntityTransformer<T>	Create an entity of type T using its Default Constructor if the input is null; and if its not null will delegate the input to DefaultCreateEntityTransformer.queryTransformer (if defined), to fetch T from it.
DefaultValueTransformer<T>	Allows one to simply provide a default value.
DoNothingTransformer	As the name suggests, in complex operations it maybe required to pass a transformer for the sake of continuity. Functionally this does nothing but pass the input back as output.
DurationFromDate	Get a String from a Date.
DynaBeanValueLookupTransformer	For a passed in DynaBean, lookup a Key. Many JSON transformations that
EmptyToNullTransformer	If a String is Empty (length = 0) then convert it to Null
EncodeDecodeTransformer	Encode or Decode using a Character set
EnsureAccessorExistsTransformer	This Transformer does not apply any Transformation on the input itself (unless there is no intermediate object), however for the intermediate object passed it ensures for an accessor chain like entity.attributes.attrib1 the necessary instances like "attributes" and "attrib1" exist else while setting one will get NullPointerExceptions.
EntityChainAccessModifierTransformer	A convenient way to modify an entity accessor (e.g.
EntityChainAccessTransformer	A convenient way to access (read only) an entity; and derive the accessor object or value using any of the following methods: Dot chaining convention like "a.b.c".
EntityFieldsCopyTransformer<T,F>	Copies fields from an Entity to another (accepts an array or Iterable of 2 objects FROM and a Collection of TO). If the input is not an array type, it assumes it as the INPUT object and generates a clone with the required copy.
EntityPropertyTransformer	Takes a property from an Entity and applies a Transformer over it.
EntitySelfTransformer<E>	Allows an entty to make changes to itself with self mappings to make internal transformations to the entity.
EntityToListTransformer<ENTITY,T>	A special type of AbstractEntityTransformer that converts an Entity to a List The size of the Array depends on the AbstractEntityTransformer.getColumnFieldMapping() + AbstractEntityTransformer.getNonAssiciatedMappers() The tuple itself is available in the intermediateObjects Map as "tuple" and original entity as "entity" Mapper field Name is expected to be column number, starting from 0
EntityToMapTransformer	Convert an entity to a Map
EntityToObjectArrayTransformer<ENTITY>	Convert an Entity to an Object Array The size of the Array depends on the AbstractEntityTransformer.getColumnFieldMapping() + AbstractEntityTransformer.getNonAssiciatedMappers() The tuple itself is available in the intermediateObjects Map as "tuple" and original entity as "entity" Mapper field Name is expected to be column number, starting from 0
EnumListTransformer<E>	Get all the Enum's within an Enum as a List of that type for each enum. The ecum in question can be sent as a Class as input or set in EnumListTransformer.enumType. If input is set and a class will override EnumListTransformer.enumType
EqualsTransformer	Simple Equals check on a EqualsTransformer.value
ExcelNumberToDateStringTransformer	In FHF, date is parsed and processed as instance of Number and converted back to date format
ExcelNumberToTimeStringTransformer	In FHF, time in 12-hour format is parsed and processed as instance of Number and converted back to 12-hour format
FileDeleteTransformer	Delete a given File and returns success (true) or fail (false)
FileToNameTransformer	Get a File absolute path with name or just name
FileWriterTransformer	Writes a File; using a FileWriterTransformer.textSupplier that supplies String or anything that can be toString() or an OutputStream
GenerateListTransformer	Generate a List or Array from a given input Note: This will allow null values.
IdentifiableTransformer<T>	During processing it maybe required to identify the Transformer associated with a process.
IterableElementCountTransformer	For a Iterable [B,A,C,A,A,B] return a Map of Count for each element as {B:2, A:3, C:1}
IterableElementIndexTransformer	For a Iterable [B,A,C,B] return a Map of Position of the elements in the index {B:0, A:1, C:2} If an Element is repeated and IterableElementIndexTransformer.trackMultipleIndeces is false; the last encountered index will be the one that is counted. If IterableElementIndexTransformer.trackMultipleIndeces is true then [B,A,C,B] --> {B:[0,3], A:[1], C:[2]} will be returned This works for any Iterable input however the order relies on assumption that the input has a consistent order.
IterableToMapTransformer	Based on a expected order of elements in IterableToMapTransformer.sequence; where each element can be mapped to a name in a map due to predictability of its order index.
JoinTransformer<T>	Joins multiple Transformers result as input in a Serial fashion (order of the List of Transformers provided) If no processor is provided (null value); then the output is the same as input.
JSONTransformer	Convert JSON String/Object to an Object.
LastStateLatchTransformer	If we have a List or Set of records that are delimited or separated by some logically identifiable variables then it is desireable to have a state-ful mechanism that can tell us what state does the current record belong in based on its delimited position. Example: +--------------------------------------------------------------+ | DELIM 1 | Rec1 | Rec2 | Rec3 | DELIM 2 | RecA | RecB | RecC | +--------------------------------------------------------------+ ..
ListArrayTransformer<T>	Convert Array to a List and a List to an Array.
ListConcatTransformer	Joins (merges) Lists or processors that result in a List, into a List in the order they are configured. If an input is provided then that input is passed on in parallel to all processors.
ListTrimTransformer	Convenience transformer to Remove elements from a List or Array by index.
LogTransformer	Log the input to the logger and return the input unchanged. Useful for debugging or intercepting Transformer, Lookup flows and Chains If Logger.isDebugEnabled() then log will happen @ debug level or @ info level.
MapCleanTransformer	Remove unnecessary elements from a Map.
MapConcatTransformer	Joins multiple Maps or Map.Entrys in sequence (best as can supported by LinkedHashMap).
MapToCollectionTransformer	Convert a Map's Entry values to a Collection The order is determined by the order Map.entrySet() iterates. By default the collection type is ArrayList
MapToEntitiesTransformer	ParamsRequestToEntitiesTransformer for Map
MapTransformer	Take a Map and apply Transformer that matches each Key.
MapValueLookupTransformer	For a key key-map (MapValueLookupTransformer.key) fetch the value using the input as a key OR For a passed in Map, lookup a Key One can optionally apply a transformation on the looked up value or even a MapValueLookupTransformer.keyTransformer on the key to derive the final key value to do the lookup.
MergeCols	During an ETL transformation merge multiple columns in a tuple, into a Map OR JSON (if MergeCols.transformer is a JSONTransformer.
MethodInvokingTransformer	Spring MethodInvokingFactoryBean Transformer.
MonthStrFormatToDateStrTransformer	In FHF, dates in format mm/yyyy are parsed as dd/mm/yyyy by adding 01 in them
MonthYearToStringTransformer	In FHF, this transformer is used to display date in MM/yyyy format during reverse ETL.
NonSerializableTransformer
NullifyEmptyObjects	If there is an empty String, Map, Collection,JSON etc.
NullToBooleanTransformer	Deprecated @see NullFilter.getDefaultValue() or DefaultValueTransformer
NumberTransformer	Converts a String to a Number; it extracts the number and cleans out characters. Example: INR 4,000 = 4000.0, or 4,00$ = 400.0 If there are multiple numbers then the first one is picked up You can set the Number Class Type also; or let NumberUtils.createNumber(String) decide the type
ObjectArrayToEntityTransformer<ENTITY>	Convert Object[] into an Entity. Useful to convert raw data bindings from an OR result (Object[]) to an Entity.
ObjectFieldValueTransformer	Extracts the Field value of an Object.
ObjectToArrayTransformer	Package an Object in a Object[] array.
ObjectToListTransformer	Package an Object in a List.
ParamsRequestToEntitiesTransformer<T>	Creates a Mapping of 'Param type class' representing the entity to the actual entities instance.
ParamsRequestToEntitiesTransformer.PropertyBinding
PrefixSuffixTransformer	Deprecated @see StringConcatTransformer
ProxyInstanceTransformer<T>	Create a new proxy/clone object from an existing object and override it with @ProxyInstanceTransformer.fieldValueMap if its provided.
RegexCleanTransformer	Converts Object to String (using toString()) and Cleans out patterns matching the Regex specified
RegexExtractorTransformer	Extract first matching RegEx String
RegexReplaceTransformer	Converts parts of string that match a pattern and applies a transformation to those parts
RelatedEntityJSONTransformer	Allows to convert a List of String input into a format that can be flexible enough to describe the relation to other Entities using any identifier like SKU, Product Code, Model Code etc.
RelatedEntityReverseJSONTransformer	Allows to convert a JSON String input to a Collection , to describe the relation to other Entities using any identifier like SKU, Product Code, Model Code etc.
ReplaceNullTransformer	Replace Null with a replacement Object
ResultSetTransformer	Apply Transformer on each Row of a result-set.
ReverseTransformer	Reverse a List, or reverse a Map key with values and visa-versa
SeedTransformer<T>	A Transformer that does not consider the input parameter and is usually the Seed for a Chain of transformations.
SizeLengthTransformer	Return numeric size for a Collection or Array
SmartSingleValuesTransformer	Many transport mechnaisms and requests may default use Arrays or Collections as values in a Data-Structure (most preferbly a Map).
SpELTransformer	Spring SpEL Transformer that evaluates a given the input or SpELTransformer.context.
StringConcatTransformer	Joins results into a single String
StringToEnumTransformer	Convert a String to its Enum type
StringToListTransformer	Convert a String to a List of Strings Transformer.
ThreadLocalTransformer	Passes the UsesIntermediateObjectImpl.determineInput(Object) into a ThreadLocal variable
ThrowableToMessageTransformer	Marshal Throwable to its message
ToNullTransformer	Nullify Objects that equal to ToNullTransformer.getValueToCompare()
TrimCleanTransformer	Converts Object to String (using toString()) and trims it
TryCatchTransformer	Allows for try, catch, finally Sand-Boxing of Calls to transformers
TypeBooleanTransformer	Converts a Object to Boolean; will return true if input is true, nulls will be ignored.
TypeDoubleTransformer	Deprecated use NumberTransformer
TypeIntegerTransformer	Deprecated use NumberTransformer
TypeStringTransformer	Converts a Object to String; will return true if input is true, nulls will be ignored
URLGeneratorTransformer	Specialized use case of StringConcatTransformer used to generate URLs. In this a processor is expeected to return a param=value pair.
UsesIntermediateObjectImpl<CONTEXT>	Basic implementation for UsesIntermediateObject
UsesIntermediateObjectWrapper<T extends org.apache.commons.collections.Transformer>	Allow a processor; Transformer, Lookup to be wrapped in this to allow for re-suing existing processors instead of extending UsesIntermediateObjectImpl for every new use case.

Enum Summary

Enum	Description
CaseTransformer.Case