Package com.tangosol.util.filter

Class PartitionedFilter<T>

java.lang.Object
com.tangosol.util.Base
com.tangosol.util.BitHelper
com.tangosol.util.ExternalizableHelper
com.tangosol.util.filter.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:

  • Constructor Details

    • 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 Details

    • 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

    • 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