Package com.tangosol.util.filter

Class PartitionedFilter<T>

  • All Implemented Interfaces:
    ExternalizableLite, PortableObject, Filter<T>, EntryFilter<Object,​T>, Serializable
    public class PartitionedFilter<T>
extends ExternalizableHelper
implements Filter<T>, EntryFilter<Object,​T>, ExternalizableLite, PortableObject
    Filter which limits the scope of another filter to those entries that have keys that belong to the specified partition set.

    This filter is intended to be used in advanced scenarios, when a caller wants to retrieve the results of parallel processing restricted to a subset of partitions. This approach may somewhat complicate the client code, but can dramatically reduce the memory footprint used by the requestor.

    Below are two examples of PartitionedFilter usage:

    • Run a parallel query partition-by-partition: 
       void executeByPartitions(NamedCache cache, Filter filter)
     {
     DistributedCacheService service =
         (DistributedCacheService) cache.getCacheService();
     int cPartitions = service.getPartitionCount();

     PartitionSet parts = new PartitionSet(cPartitions);
     for (int iPartition = 0; iPartition < cPartitions; iPartition++)
         {
         parts.add(iPartition);

         Filter filterPart = new PartitionedFilter(filter, parts);

         Set setEntriesPart = cache.entrySet(filterPart);

         // process the entries ...

         parts.remove(iPartition);
         }
     }
    • Run a parallel query member-by-member: 
       void executeByMembers(NamedCache cache, Filter f)
     {
     DistributedCacheService service =
         (DistributedCacheService) cache.getCacheService();
     int cPartitions = service.getPartitionCount();

     PartitionSet partsProcessed = new PartitionSet(cPartitions);
     for (Iterator iter = service.getStorageEnabledMembers().iterator();
             iter.hasNext();)
         {
         Member member = (Member) iter.next();

         PartitionSet partsMember = service.getOwnedPartitions(member);

         // due to a redistribution some partitions may have already been processed
         partsMember.remove(partsProcessed);

         Filter filterPart = new PartitionedFilter(filter, partsMember);
         Set setEntriesPart = cache.entrySet(filterPart);

         // process the entries ...

         partsProcessed.add(partsMember);
         }

     // due to a possible redistribution, some partitions may have been skipped
     if (!partsProcessed.isFull())
         {
         partsProcessed.invert();
         Filter filter = new PartitionedFilter(filter, partsProcessed);

         // process the remaining entries ...
         }
     }
    Note: This filter must be the outermost filter and cannot be used as a part of any composite filter (AndFilter, OrFilter, etc.)

    To iterate through a query on a partition-by-partition or member-by-member basis, use the PartitionedIterator class.

    Since:
    Coherence 3.4
    Author:
    gg 2008.02.06
    See Also:
    Serialized Form

    • Constructor Detail

      • PartitionedFilter

        public PartitionedFilter()
        Default constructor (necessary for the ExternalizableLite interface).

      • PartitionedFilter

        public PartitionedFilter​(Filter<T> filter,
                         PartitionSet partitions)
        Construct a PartitionedFilter.
        Parameters:
        filter - the underlying (wrapped) filter
        partitions - the subset of partitions the filter should run against

    • Method Detail

      • evaluate

        public boolean evaluate​(T o)
        Apply the test to the input argument.
        Specified by:
        evaluate in interface Filter<T>
        Parameters:
        o - the input argument to evaluate
        Returns:
        true if the input argument matches the filter, otherwise false

      • evaluateEntry

        public boolean evaluateEntry​(Map.Entry entry)
        Apply the test to a Map Entry.
        Specified by:
        evaluateEntry in interface EntryFilter<Object,​T>
        Parameters:
        entry - the Map Entry to evaluate; never null
        Returns:
        true if the test passes, false otherwise

      • getFilter

        public Filter<T> getFilter()
        Obtain the wrapped Filter.
        Returns:
        the wrapped filter object

      • getPartitionSet

        public PartitionSet getPartitionSet()
        Obtain the PartitionSet that specifies what partitions the wrapped filter will be applied to.
        Returns:
        the partition set

      • equals

        public boolean equals​(Object o)
        Compare the PartitionedFilter with another object to determine equality. Two PartitionedFilter objects are considered equal iff the wrapped filters and partition sets are equal.
        Overrides:
        equals in class Object
        Returns:
        true iff this PartitionedFilter and the passed object are equivalent PartitionedFilter objects

      • hashCode

        public int hashCode()
        Determine a hash value for the PartitionedFilter object according to the general Object.hashCode() contract.
        Overrides:
        hashCode in class Object
        Returns:
        an integer hash value for this PartitionedFilter object

      • toString

        public String toString()
        Return a human-readable description for this Filter.
        Overrides:
        toString in class Object
        Returns:
        a String description of the Filter

      • readExternal

        public void readExternal​(DataInput in)
                  throws IOException
        Restore the contents of this object by loading the object's state from the passed DataInput object.
        Specified by:
        readExternal in interface ExternalizableLite
        Parameters:
        in - the DataInput stream to read data from in order to restore the state of this object
        Throws:
        IOException - if an I/O exception occurs
        NotActiveException - if the object is not in its initial state, and therefore cannot be deserialized into

      • writeExternal

        public void writeExternal​(DataOutput out)
                   throws IOException
        Save the contents of this object by storing the object's state into the passed DataOutput object.
        Specified by:
        writeExternal in interface ExternalizableLite
        Parameters:
        out - the DataOutput stream to write the state of this object to
        Throws:
        IOException - if an I/O exception occurs

      • readExternal

        public void readExternal​(PofReader in)
                  throws IOException
        Restore the contents of a user type instance by reading its state using the specified PofReader object.
        Specified by:
        readExternal in interface PortableObject
        Parameters:
        in - the PofReader from which to read the object's state
        Throws:
        IOException - if an I/O error occurs

      • writeExternal

        public void writeExternal​(PofWriter out)
                   throws IOException
        Save the contents of a POF user type instance by writing its state using the specified PofWriter object.
        Specified by:
        writeExternal in interface PortableObject
        Parameters:
        out - the PofWriter to which to write the object's state
        Throws:
        IOException - if an I/O error occurs