src/main/java/jp/sourceforge/stigmata/filter/FilteredComparisonResultSet.java

   1 package jp.sourceforge.stigmata.filter;
   2
   3 /*
   4  * $Id$
   5  */
   6
   7 import java.util.ArrayList;
   8 import java.util.Iterator;
   9 import java.util.List;
  10
  11 import jp.sourceforge.stigmata.BirthmarkContext;
  12 import jp.sourceforge.stigmata.BirthmarkEnvironment;
  13 import jp.sourceforge.stigmata.BirthmarkSet;
  14 import jp.sourceforge.stigmata.ComparisonPair;
  15 import jp.sourceforge.stigmata.ComparisonPairFilterSet;
  16 import jp.sourceforge.stigmata.ComparisonResultSet;
  17
  18 /**
  19  * Filtering {@link ComparisonResultSet <code>ComparisonResultSet</code>}.
  20  *
  21  * @author Haruaki TAMADA
  22  * @version $Revision$
  23  */
  24 public class FilteredComparisonResultSet implements ComparisonResultSet{
  25     private ComparisonResultSet resultset;
  26     private List<ComparisonPairFilterSet> filters = new ArrayList<ComparisonPairFilterSet>();
  27
  28     /**
  29      * constructor.
  30      *
  31      * @param resultset filtering target
  32      */
  33     public FilteredComparisonResultSet(ComparisonResultSet resultset){
  34         this.resultset = resultset;
  35     }
  36
  37     /**
  38      * constructor.
  39      * @param resultset filtering target
  40      * @param filters filtering rule
  41      */
  42     public FilteredComparisonResultSet(ComparisonResultSet resultset, ComparisonPairFilterSet[] filters){
  43         this.resultset = resultset;
  44         for(int i = 0; i < filters.length; i++){
  45             addFilterSet(filters[i]);
  46         }
  47     }
  48
  49     public void addFilterSet(ComparisonPairFilterSet filter){
  50         filters.add(filter);
  51     }
  52
  53     public void removeFilterSet(ComparisonPairFilterSet filter){
  54         filters.remove(filter);
  55     }
  56
  57     @Override
  58     public ComparisonPair getPairAt(int index){
  59         int currentIndex = 0;
  60         for(Iterator<ComparisonPair> i = iterator(); i.hasNext(); ){
  61             ComparisonPair pair = i.next();
  62             if(currentIndex == index){
  63                 return pair;
  64             }
  65             currentIndex++;
  66         }
  67         return null;
  68     }
  69
  70     @Override
  71     public ComparisonPair[] getPairs(){
  72         List<ComparisonPair> list = new ArrayList<ComparisonPair>();
  73         for(Iterator<ComparisonPair> i = iterator(); i.hasNext(); ){
  74             list.add(i.next());
  75         }
  76         return list.toArray(new ComparisonPair[list.size()]);
  77     }
  78
  79     @Override
  80     public int getPairCount(){
  81         return resultset.getPairCount();
  82     }
  83
  84     @Override
  85     public BirthmarkContext getContext(){
  86         return resultset.getContext();
  87     }
  88
  89     @Override
  90     public BirthmarkEnvironment getEnvironment(){
  91         return resultset.getEnvironment();
  92     }
  93
  94     @Override
  95     public Iterator<ComparisonPair> iterator(){
  96         return new FilteredIterator(resultset.iterator());
  97     }
  98
  99     @Override
 100     public synchronized BirthmarkSet[] getPairSources(){
 101         List<BirthmarkSet> list = new ArrayList<BirthmarkSet>();
 102         for(Iterator<BirthmarkSet> i = pairSources(); i.hasNext(); ){
 103             list.add(i.next());
 104         }
 105         return list.toArray(new BirthmarkSet[list.size()]);
 106     }
 107
 108     @Override
 109     public Iterator<BirthmarkSet> pairSources(){
 110         return resultset.pairSources();
 111     }
 112
 113     private class FilteredIterator implements Iterator<ComparisonPair>{
 114         private Iterator<ComparisonPair> iterator;
 115         private ComparisonPair next;
 116
 117         public FilteredIterator(Iterator<ComparisonPair> iterator){
 118             this.iterator = iterator;
 119
 120             next = findNext();
 121         }
 122
 123         @Override
 124         public boolean hasNext(){
 125             return next != null;
 126         }
 127
 128         @Override
 129         public ComparisonPair next(){
 130             ComparisonPair returnValue = next;
 131             next = findNext();
 132             return returnValue;
 133         }
 134
 135         @Override
 136         public void remove(){
 137             throw new InternalError("not implemented");
 138         }
 139
 140         private ComparisonPair findNext(){
 141             boolean nowFinding = true;
 142             while(nowFinding && iterator.hasNext()){
 143                 ComparisonPair nextPair = iterator.next();
 144                 // return the pair which the all filters is passed
 145                 if(isAllFilterPassed(nextPair)){
 146                     nowFinding = false; // found next value!
 147                     next = nextPair;
 148                 }
 149             }
 150             if(nowFinding && !iterator.hasNext()){
 151                 next = null;
 152             }
 153             return next;
 154         }
 155
 156         private boolean isAllFilterPassed(ComparisonPair pair){
 157             boolean flag = true;
 158             for(Iterator<ComparisonPairFilterSet> i = filters.iterator(); i.hasNext(); ){
 159                 ComparisonPairFilterSet filter = i.next();
 160                 if(!filter.isFiltered(pair)){
 161                     flag = false;
 162                     break;
 163                 }
 164             }
 165             return flag;
 166         }
 167     };
 168 }