Package com.tangosol.util

Class Processors

  • public class Processors
extends Object
    Simple InvocableMap.EntryProcessor DSL.

    Contains factory methods and entry processor classes that are used to implement functionality exposed via different variants of NamedCache API.

    Since:
    14.1.1.0
    Author:
    mk 2019.07.26

    • Constructor Detail

      • Processors

        public Processors()

    • Method Detail

      • asynchronous

        public static <K,​V,​R> InvocableMap.EntryProcessor<K,​V,​R> asynchronous​(InvocableMap.EntryProcessor<K,​V,​R> processor,
                                                                                              int iUnitOrderId)
        Construct an asynchronous processor for a given processor with unit-of-order id.
        Type Parameters:
        K - the type of the Map entry key
        V - the type of the Map entry value
        R - the type of value returned by the EntryProcessor
        Parameters:
        processor - the underlying InvocableMap.EntryProcessor
        iUnitOrderId - the unit-of-order id for this processor
        Returns:
        an aynchronous processor for a given processor with unit-of-order id
        See Also:
        AsynchronousProcessor

      • streamingAsynchronous

        public static <K,​V,​R> InvocableMap.EntryProcessor<K,​V,​R> streamingAsynchronous​(InvocableMap.EntryProcessor<K,​V,​R> processor,
                                                                                                       Consumer<? super Map.Entry<? extends K,​? extends R>> onPartial)
        Construct a streaming asynchronous processor for a given processor and one or more callbacks.

        Important Note: All provided callbacks must be non-blocking. For example, any use of NamedCache API is completely disallowed.

        Parameters:
        processor - the underlying InvocableMap.EntryProcessor
        onPartial - a user-defined callback that will be called for each partial result
        Returns:
        a streaming asynchronous processor for a given processor and one or more callbacks
        See Also:
        StreamingAsynchronousProcessor

      • streamingAsynchronous

        public static <K,​V,​R> InvocableMap.EntryProcessor<K,​V,​R> streamingAsynchronous​(InvocableMap.EntryProcessor<K,​V,​R> processor,
                                                                                                       int iUnitOrderId,
                                                                                                       Consumer<? super Map.Entry<? extends K,​? extends R>> onPartial)
        Construct a streaming asynchronous processor for a given processor and one or more callbacks.

        Important Note: All provided callbacks must be non-blocking. For example, any use of NamedCache API is completely disallowed.

        Parameters:
        processor - the underlying InvocableMap.EntryProcessor
        iUnitOrderId - the unit-of-order id for this processor
        onPartial - a user-defined callback that will be called for each partial result
        Returns:
        a streaming asynchronous processor for a given processor and one or more callbacks
        See Also:
        StreamingAsynchronousProcessor

      • composite

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​Object> composite​(InvocableMap.EntryProcessor<K,​V,​?>[] aProcessor)
        Construct a composite processor for the specified array of individual entry processors.

        The result of the composite processor execution is an array of results returned by the individual EntryProcessor invocations.

        Type Parameters:
        K - the type of the Map entry key
        V - the type of the Map entry value
        Parameters:
        aProcessor - the entry processor array
        Returns:
        a composite processor for the specified array of individual entry processors.
        See Also:
        CompositeProcessor

      • conditional

        public static <K,​V,​T> InvocableMap.EntryProcessor<K,​V,​T> conditional​(Filter<V> filter,
                                                                                             InvocableMap.EntryProcessor<K,​V,​T> processor)
        Construct a conditional processor for a specified filter and the processor.

        The specified entry processor gets invoked if and only if the filter applied to the InvocableMap entry evaluates to true; otherwise the result of the process invocation will return null.

        Type Parameters:
        K - the type of the Map entry key
        V - the type of the Map entry value
        T - the type of value returned by the EntryProcessor
        Parameters:
        filter - the filter
        processor - the entry processor
        Returns:
        a conditional processor for a specified filter and the processor.
        See Also:
        ConditionalProcessor

      • put

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> put​(Filter filter,
                                                                             V value)
        Construct a put processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true. The result of the process invocation does not return any result.
        Type Parameters:
        V - the type of the Map entry value
        Parameters:
        filter - the filter to evaluate an entry
        value - a value to update an entry with
        Returns:
        a put processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true

      • put

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> put​(Filter filter,
                                                                             V value,
                                                                             boolean fReturn)
        Construct a put processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true. This processor optionally returns the current value as a result of the invocation if it has not been updated (the filter evaluated to false).
        Type Parameters:
        V - the type of the Map entry value
        Parameters:
        filter - the filter to evaluate an entry
        value - a value to update an entry with
        fReturn - specifies whether or not the processor should return the current value in case it has not been updated
        Returns:
        a put processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true.

      • putAll

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> putAll​(Filter filter,
                                                                                Map<? extends K,​? extends V> map)
        Construct a putAll processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true. The new value is extracted from the specified map based on the entry's key.
        Type Parameters:
        K - the type of the Map entry key
        V - the type of the Map entry value
        Parameters:
        filter - the filter to evaluate all supplied entries
        map - a map of values to update entries with
        Returns:
        a putAll processor that updates an entry with a new value if and only if the filter applied to the entry evaluates to true.

      • remove

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​Boolean> remove()
        Construct a remove processor that unconditionally removes an InvocableMap entry. The invocation of the created processor does not return any result.
        Returns:
        a remove processor that unconditionally removes an InvocableMap entry

      • remove

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> remove​(boolean fReturn)
        Construct a remove processor that unconditionally removes an InvocableMap entry, and optionally returns the removed value.
        Parameters:
        fReturn - the flag specifying whether to return the value that was removed
        Returns:
        a remove processor that unconditionally removes an InvocableMap entry

      • remove

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> remove​(Filter filter)
        Construct a remove processor that removes an InvocableMap entry if and only if the filter applied to the entry evaluates to true. The invocation of the created processor does not return any result.

        Note: If the goal is to remove entries from a map based on a certain criteria, it is significantly more efficient to pass the processor created by the remove() method to InvocableMap.invokeAll(Filter, EntryProcessor). That way filtering will be performed ahead of time, using any available indexes for optimization, so the number of entries the processor is executed against will be reduced. The processor returned by this method should only be used when that is not possible.

        Parameters:
        filter - the filter to evaluate an entry
        Returns:
        a remove processor that removes an InvocableMap entry if and only if the filter applied to the entry evaluates to true.

      • remove

        public static <K,​V> InvocableMap.EntryProcessor<K,​V,​V> remove​(Filter filter,
                                                                                boolean fReturn)
        Construct a remove processor that removes an InvocableMap entry if and only if the filter applied to the entry evaluates to true. This processor may optionally return the current value as a result of the invocation if it has not been removed (the filter evaluated to false).

        Note: If the goal is to remove entries from a map based on a certain criteria, it is significantly more efficient to pass the processor created by the remove() method to InvocableMap.invokeAll(Filter, EntryProcessor). That way filtering will be performed ahead of time, using any available indexes for optimization, so the number of entries the processor is executed against will be reduced. The processor returned by this method should only be used when that is not possible.

        Parameters:
        filter - the filter to evaluate an entry
        fReturn - specifies whether or not the processor should return the current value if it has not been removed
        Returns:
        a remove processor that removes an InvocableMap entry if and only if the filter applied to the entry evaluates to true.

      • extract

        public static <K,​V,​R> InvocableMap.EntryProcessor<K,​V,​R> extract​(String sName)
        Construct an extract processor for a given property or method name.
        Parameters:
        sName - a property or method name to make a ValueExtractor for; this parameter can also be a dot-delimited sequence of names which would result in an ExtractorProcessor based on the ChainedExtractor that is based on an array of corresponding ValueExtractor objects
        Returns:
        an extract processor for a given property or method name
        See Also:
        ExtractorProcessor

      • increment

        public static <K,​V,​N extends Number> InvocableMap.EntryProcessor<K,​V,​N> increment​(String sName,
                                                                                                          N numInc,
                                                                                                          boolean fPostIncrement)
        Construct an increment processor that will increment a property value by a specified amount, returning either the old or the new value as specified. The Java type of the numInc parameter will dictate the Java type of the original and the new value.
        Parameters:
        sName - the property name
        numInc - the Number representing the magnitude and sign of the increment
        fPostIncrement - pass true to return the value as it was before it was incremented, or pass false to return the value as it is after it is incremented
        Returns:
        an increment processor
        See Also:
        NumberIncrementor

      • increment

        public static <K,​V,​N extends Number> InvocableMap.EntryProcessor<K,​V,​N> increment​(PropertyManipulator manipulator,
                                                                                                          N numInc,
                                                                                                          boolean fPostIncrement)
        Construct an increment processor that will increment a property value by a specified amount, returning either the old or the new value as specified. The Java type of the numInc parameter will dictate the Java type of the original and the new value.
        Parameters:
        manipulator - the Manipulator; could be null
        numInc - the Number representing the magnitude and sign of the increment
        fPostIncrement - pass true to return the value as it was before it was incremented, or pass false to return the value as it is after it is incremented
        Returns:
        an increment processor
        See Also:
        NumberIncrementor

      • multiply

        public static <K,​V,​N extends Number> InvocableMap.EntryProcessor<K,​V,​N> multiply​(String sName,
                                                                                                         N numFactor,
                                                                                                         boolean fPostFactor)
        Construct a multiply processor that will multiply a property value by a specified factor, returning either the old or the new value as specified. The Java type of the original property value will dictate the way the specified factor is interpreted. For example, applying a factor of Double(0.5) to a property value of Integer(4) will result in a new property value of Integer(2).
        If the original property value is null, the Java type of the numFactor parameter will dictate the Java type of the new value.
        Parameters:
        sName - the property name
        numFactor - the Number representing the magnitude and sign of the multiplier
        fPostFactor - pass true to return the value as it was before it was multiplied, or pass false to return the value as it is after it is multiplied
        Returns:
        a multiply processor that will multiply a property value by a specified factor, returning either the old or the new value as specified
        See Also:
        NumberMultiplier

      • multiply

        public static <K,​V,​N extends Number> InvocableMap.EntryProcessor<K,​V,​N> multiply​(PropertyManipulator<V,​N> manipulator,
                                                                                                         N numFactor,
                                                                                                         boolean fPostFactor)
        Construct a multiply processor that will multiply a property value by a specified factor, returning either the old or the new value as specified. The Java type of the original property value will dictate the way the specified factor is interpreted. For example, applying a factor of Double(0.5) to a property value of Integer(4) will result in a new property value of Integer(2).
        If the original property value is null, the Java type of the numFactor parameter will dictate the Java type of the new value.
        Parameters:
        manipulator - the Manipulator; could be null
        numFactor - the Number representing the magnitude and sign of the multiplier
        fPostFactor - pass true to return the value as it was before it was multiplied, or pass false to return the value as it is after it is multiplied
        Returns:
        a multiply processor that will multiply a property value by a specified factor, returning either the old or the new value as specified
        See Also:
        NumberMultiplier

      • manipulate

        public static <V,​R> PropertyManipulator<V,​R> manipulate​(String sName)
        Construct a property manipulate processor for the specified property name.
        Parameters:
        sName - a property name
        Returns:
        a property manipulate processor for the specified property name
        See Also:
        PropertyManipulator

      • manipulate

        public static <V,​R> PropertyManipulator<V,​R> manipulate​(String sName,
                                                                    boolean fUseIs)
        Construct a property manipulate processor for the specified property name.

        This constructor assumes that the corresponding property getter will have a name of either ("get" + sName) or ("is + sName) and the corresponding property setter's name will be ("set + sName).

        Parameters:
        sName - a property name
        fUseIs - if true, the getter method will be prefixed with "is" rather than "get"
        Returns:
        a property manipulate processor for the specified property name
        See Also:
        PropertyManipulator

      • update

        public static <K,​V,​T> InvocableMap.EntryProcessor<K,​V,​Boolean> update​(ValueUpdater<V,​T> updater,
                                                                                              T value)
        Construct an update processor based on the specified ValueUpdater.
        Parameters:
        updater - a ValueUpdater object; passing null will simpy replace the entry's value with the specified one instead of updating it
        value - the value to update the target entry with
        Returns:
        an update processor
        See Also:
        UpdaterProcessor

      • update

        public static <K,​V,​T> InvocableMap.EntryProcessor<K,​V,​Boolean> update​(String sMethod,
                                                                                              T value)
        Construct an update processor for a given method name. The method must have a single parameter of a Java type compatible with the specified value type.
        Parameters:
        sMethod - a method name to make an ValueUpdater for; this parameter can also be a dot-delimited sequence of method names which would result in using a CompositeUpdater
        value - the value to update the target entry with
        Returns:
        an update processor for a given method name
        See Also:
        UpdaterProcessor

      • versionedPut

        public static <K,​V extends Versionable> InvocableMap.EntryProcessor<K,​V,​V> versionedPut​(V oValue)
        Construct a versioned put processor that updates an entry with a new value if and only if the version of the new value matches to the version of the current entry's value (which must exist). The result of the process invocation does not return any result.
        Parameters:
        oValue - a Versionable value to update an entry with
        Returns:
        a versioned put
        See Also:
        VersionedPut

      • versionedPut

        public static <K,​V extends Versionable> InvocableMap.EntryProcessor<K,​V,​V> versionedPut​(V oValue,
                                                                                                          boolean fAllowInsert,
                                                                                                          boolean fReturn)
        Construct a versioned put processor that updates an entry with a new value if and only if the version of the new value matches to the version of the current entry's value. This processor optionally returns the current value as a result of the invocation if it has not been updated (the versions did not match).
        Parameters:
        oValue - a value to update an entry with
        fAllowInsert - specifies whether or not an insert should be allowed (no currently existing value)
        fReturn - specifies whether or not the processor should return the current value in case it has not been updated
        Returns:
        a versioned put
        See Also:
        VersionedPut

      • versionedPutAll

        public static <K,​V extends Versionable> InvocableMap.EntryProcessor<K,​V,​V> versionedPutAll​(Map<? extends K,​? extends V> map)
        Construct a versioned putAll processor that updates an entry with a new value if and only if the version of the new value matches to the version of the current entry's value (which must exist). The result of the process invocation does not return any result.
        Parameters:
        map - a map of values to update entries with
        Returns:
        a versioned putAll processor
        See Also:
        VersionedPutAll

      • versionedPutAll

        public static <K,​V extends Versionable> InvocableMap.EntryProcessor<K,​V,​V> versionedPutAll​(Map<? extends K,​? extends V> map,
                                                                                                             boolean fAllowInsert,
                                                                                                             boolean fReturn)
        Construct a versioned putAll processor that updates an entry with a new value if and only if the version of the new value matches to the version of the current entry's value (which must exist). This processor optionally returns a map of entries that have not been updated (the versions did not match).
        Parameters:
        map - a map of values to update entries with
        fAllowInsert - specifies whether or not an insert should be allowed (no currently existing value)
        fReturn - specifies whether or not the processor should return the entries that have not been updated
        Returns:
        a versioned putAll processor
        See Also:
        VersionedPutAll