Accessing index directly from backing map

Question

Hi Guys,
I have an interesting problem and would greatly appreciate some input.
I am trying to find the minimum or maximum values of a specific field from data held
in the backing map for a cache.
I have seen examples of PofValue being used to extract individual entries - or being used in
Iterators, working through the entries in the backing map.
However, I was wondering if there is a faster way to do this, given that the field I'm interested in
has an ordered index created against it.
My thoughts were along the lines of trying to extract the Mapindex entries for the field, and just then
taking the first value (which, I'm assuming, would be the smallest since the index is ordered).
Does this make sense, or do I need to abandon the idea of using the pre-existing index and just iterate through
the PofValues? Is it even possible to access the index entries for values directly from the backing map?
Many Thanks,
Adrian.

Answer 1

Hi Adrian,
you should be able to write an index-aware filter which makes this really fast, provided that you have a sorted index on the particular attribute which sorts according to the same order (or reverse) according to which you want the least or highest value. The following Filter implementation filters for the entries with the least extracted value:
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import com.tangosol.util.Filter;
import com.tangosol.util.MapIndex;
import com.tangosol.util.filter.ExtractorFilter;
import com.tangosol.util.filter.IndexAwareFilter;
public class LeastExtractedValueFilter extends ExtractorFilter implements IndexAwareFilter {
   public LeastExtractedValueFilter(ValueExtractor extractor) {
      super(extractor);
   public LeastExtractedValueFilter() {
   @Override
   protected boolean evaluateExtracted(Object extractedValue) {
      throw new UnsupportedOperationException("This filter is only usable with a sorted index");
   @Override
   public Filter applyIndex(Map mapIndexes, Set candidateKeys) {
      MapIndex mapIndex = (MapIndex) mapIndexes.get(m_extractor);
      if (mapIndex != null && mapIndex.isOrdered()) {
         SortedMap reverseMap = (SortedMap) mapIndex.getIndexContents();
         if (reverseMap.isEmpty()) {
            candidateKeys.clear();
         } else {
            candidateKeys.retainAll((Set)reverseMap.values().iterator().next());
         return null;
      throw new UnsupportedOperationException("This filter is only usable with a sorted index");
   @Override
   public int calculateEffectiveness(Map mapIndexes, Set candidateKeys) {
      MapIndex mapIndex = (MapIndex) mapIndexes.get(m_extractor);
      if (mapIndex != null && mapIndex.isOrdered()) {
         return 1;
      throw new UnsupportedOperationException("This filter is only usable with a sorted index");
}You can then try to extract whatever you want from the candidates in a parallel aggregator, e.g.:
import java.io.IOException;
import java.io.Serializable;
import java.util.Collection;
import java.util.Set;
import com.tangosol.io.pof.PofReader;
import com.tangosol.io.pof.PofWriter;
import com.tangosol.io.pof.PortableObject;
import com.tangosol.util.InvocableMap;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.InvocableMap.EntryAggregator;
import com.tangosol.util.InvocableMap.ParallelAwareAggregator;
public class FirstEntryExtractorAggregator implements ParallelAwareAggregator {
   public static class Parallel extends FirstEntryExtractorAggregator implements PortableObject, Serializable {
      public Parallel() {
         super(null);
      public Parallel(ValueExtractor extractor) {
         super(extractor);
      @Override
      public void readExternal(PofReader in) throws IOException {
         extractor = (ValueExtractor) in.readObject(0);
      @Override
      public void writeExternal(PofWriter out) throws IOException {
         out.writeObject(0, extractor);
   protected ValueExtractor extractor;
   public FirstEntryExtractorAggregator(ValueExtractor extractor) {
      super();
      this.extractor = extractor;
   @Override
   public Object aggregate(Set entries) {
      if (!entries.isEmpty()) {
         InvocableMap.Entry entry = (InvocableMap.Entry)entries.iterator().next();
         return entry.extract(extractor);
      return null;
   @Override
   public Object aggregateResults(Collection collResults) {
      Comparable least = null;
      for (Object object : collResults) {
         least = leastOf(least, object);
      return least;
   private Comparable leastOf(Comparable least, Object other) {
      if (other == null) return least;
      Comparable compOther = (Comparable) other;
      if (least == null) return compOther;
      return compOther.compareTo(least) > 0 ? least : compOther;
   @Override
   public EntryAggregator getParallelAggregator() {
      return new Parallel(extractor);
}You would then run this as:
Object leastExtractedValue = cache.aggregate(new LeastExtractedValueFilter(extractor), new FirstEntryExtractorAggregator(extractor));Best regards,
Robert
Edited by: robvarga on Sep 21, 2010 3:00 PM
Edited by: robvarga on Sep 21, 2010 7:44 PM