MtasMaximumExpandSpanQuery.java

  1. package mtas.search.spans.util;

  3. import java.io.IOException;
  4. import java.lang.reflect.Method;
  5. import java.util.Map;
  6. import java.util.Set;

  8. import org.apache.lucene.codecs.FieldsProducer;
  9. import org.apache.lucene.index.IndexReader;
  10. import org.apache.lucene.index.LeafReader;
  11. import org.apache.lucene.index.LeafReaderContext;
  12. import org.apache.lucene.index.Term;
  13. import org.apache.lucene.index.TermContext;
  14. import org.apache.lucene.index.Terms;
  15. import org.apache.lucene.search.IndexSearcher;
  16. import org.apache.lucene.search.spans.SpanWeight;
  17. import org.apache.lucene.search.spans.Spans;

  19. import mtas.codec.util.CodecInfo;
  20. import mtas.search.spans.MtasSpanMatchNoneSpans;

  22. /**
  23.  * The Class MtasMaximumExpandSpanQuery.
  24.  */
  25. public class MtasMaximumExpandSpanQuery extends MtasSpanQuery {

  27.   /** The query. */
  28.   MtasSpanQuery query;

  30.   /** The minimum left. */
  31.   int minimumLeft;

  33.   /** The maximum left. */
  34.   int maximumLeft;

  36.   /** The minimum right. */
  37.   int minimumRight;

  39.   /** The maximum right. */
  40.   int maximumRight;

  42.   /**
  43.    * Instantiates a new mtas maximum expand span query.
  44.    *
  45.    * @param query the query
  46.    * @param minimumLeft the minimum left
  47.    * @param maximumLeft the maximum left
  48.    * @param minimumRight the minimum right
  49.    * @param maximumRight the maximum right
  50.    */
  51.   public MtasMaximumExpandSpanQuery(MtasSpanQuery query, int minimumLeft,
  52.       int maximumLeft, int minimumRight, int maximumRight) {
  53.     super(null, null);
  54.     this.query = query;
  55.     if (minimumLeft > maximumLeft || minimumRight > maximumRight
  56.         || minimumLeft < 0 || minimumRight < 0) {
  57.       throw new IllegalArgumentException();
  58.     }
  59.     this.minimumLeft = minimumLeft;
  60.     this.maximumLeft = maximumLeft;
  61.     this.minimumRight = minimumRight;
  62.     this.maximumRight = maximumRight;
  63.     Integer minimum = query.getMinimumWidth();
  64.     Integer maximum = query.getMaximumWidth();
  65.     if (minimum != null) {
  66.       minimum += minimumLeft + minimumRight;
  67.     }
  68.     if (maximum != null) {
  69.       maximum += maximumLeft + maximumRight;
  70.     }
  71.     setWidth(minimum, maximum);
  72.   }

  74.   /*
  75.    * (non-Javadoc)
  76.    * 
  77.    * @see
  78.    * mtas.search.spans.util.MtasSpanQuery#createWeight(org.apache.lucene.search.
  79.    * IndexSearcher, boolean)
  80.    */
  81.   @Override
  82.   public SpanWeight createWeight(IndexSearcher searcher, boolean needsScores, float boost)
  83.       throws IOException {
  84.     SpanWeight subWeight = query.createWeight(searcher, needsScores, boost);
  85.     if (maximumLeft == 0 && maximumRight == 0) {
  86.       return subWeight;
  87.     } else {
  88.       return new MtasMaximumExpandWeight(subWeight, searcher, needsScores, boost);
  89.     }
  90.   }

  92.   /*
  93.    * (non-Javadoc)
  94.    * 
  95.    * @see org.apache.lucene.search.spans.SpanQuery#getField()
  96.    */
  97.   @Override
  98.   public String getField() {
  99.     return query.getField();
  100.   }

  102.   /*
  103.    * (non-Javadoc)
  104.    * 
  105.    * @see org.apache.lucene.search.Query#toString(java.lang.String)
  106.    */
  107.   @Override
  108.   public String toString(String field) {
  109.     StringBuilder buffer = new StringBuilder();
  110.     buffer.append(this.getClass().getSimpleName() + "([");
  111.     buffer.append(query.toString(field) + "][" + minimumLeft + "," + maximumLeft
  112.         + "][" + minimumRight + "," + maximumRight + "])");
  113.     return buffer.toString();
  114.   }

  116.   /*
  117.    * (non-Javadoc)
  118.    * 
  119.    * @see org.apache.lucene.search.Query#equals(java.lang.Object)
  120.    */
  121.   @Override
  122.   public boolean equals(Object obj) {
  123.     if (this == obj)
  124.       return true;
  125.     if (obj == null)
  126.       return false;
  127.     if (getClass() != obj.getClass())
  128.       return false;
  129.     final MtasMaximumExpandSpanQuery that = (MtasMaximumExpandSpanQuery) obj;
  130.     boolean isEqual;
  131.     isEqual = query.equals(that.query);
  132.     isEqual &= minimumLeft == that.minimumLeft;
  133.     isEqual &= maximumLeft == that.maximumLeft;
  134.     isEqual &= minimumRight == that.minimumRight;
  135.     isEqual &= maximumRight == that.maximumRight;
  136.     return isEqual;
  137.   }

  139.   /*
  140.    * (non-Javadoc)
  141.    * 
  142.    * @see org.apache.lucene.search.Query#hashCode()
  143.    */
  144.   @Override
  145.   public int hashCode() {
  146.     int h = Integer.rotateLeft(classHash(), 1);
  147.     h ^= query.hashCode();
  148.     h = Integer.rotateLeft(h, minimumLeft) + minimumLeft;
  149.     h ^= 2;
  150.     h = Integer.rotateLeft(h, maximumLeft) + maximumLeft;
  151.     h ^= 3;
  152.     h = Integer.rotateLeft(h, minimumRight) + minimumRight;
  153.     h ^= 5;
  154.     h = Integer.rotateLeft(h, maximumRight) + maximumRight;
  155.     return h;
  156.   }

  158.   /*
  159.    * (non-Javadoc)
  160.    * 
  161.    * @see mtas.search.spans.util.MtasSpanQuery#rewrite(org.apache.lucene.index.
  162.    * IndexReader)
  163.    */
  164.   @Override
  165.   public MtasSpanQuery rewrite(IndexReader reader) throws IOException {
  166.     MtasSpanQuery newQuery = query.rewrite(reader);
  167.     if (maximumLeft == 0 && maximumRight == 0) {
  168.       return newQuery;
  169.     } else if (!query.equals(newQuery)) {
  170.       return new MtasMaximumExpandSpanQuery(newQuery, minimumLeft, maximumLeft,
  171.           minimumRight, maximumRight);
  172.     } else {
  173.       return super.rewrite(reader);
  174.     }
  175.   }

  177.   /*
  178.    * (non-Javadoc)
  179.    * 
  180.    * @see mtas.search.spans.util.MtasSpanQuery#disableTwoPhaseIterator()
  181.    */
  182.   @Override
  183.   public void disableTwoPhaseIterator() {
  184.     super.disableTwoPhaseIterator();
  185.     query.disableTwoPhaseIterator();
  186.   }
  187.   
  188.   @Override
  189.   public boolean isMatchAllPositionsQuery() {
  190.     return false;
  191.   }

  193.   /**
  194.    * The Class MtasMaximumExpandWeight.
  195.    */
  196.   private class MtasMaximumExpandWeight extends MtasSpanWeight {

  198.     /** The Constant METHOD_GET_DELEGATE. */
  199.     private static final String METHOD_GET_DELEGATE = "getDelegate";

  201.     /** The Constant METHOD_GET_POSTINGS_READER. */
  202.     private static final String METHOD_GET_POSTINGS_READER = "getPostingsReader";

  204.     /** The sub weight. */
  205.     SpanWeight subWeight;

  207.     /**
  208.      * Instantiates a new mtas maximum expand weight.
  209.      *
  210.      * @param subWeight the sub weight
  211.      * @param searcher the searcher
  212.      * @param needsScores the needs scores
  213.      * @throws IOException Signals that an I/O exception has occurred.
  214.      */
  215.     public MtasMaximumExpandWeight(SpanWeight subWeight, IndexSearcher searcher,
  216.         boolean needsScores, float boost) throws IOException {
  217.       super(MtasMaximumExpandSpanQuery.this, searcher,
  218.           needsScores ? getTermContexts(subWeight) : null, boost);
  219.       this.subWeight = subWeight;
  220.     }

  222.     /*
  223.      * (non-Javadoc)
  224.      * 
  225.      * @see
  226.      * org.apache.lucene.search.spans.SpanWeight#extractTermContexts(java.util.
  227.      * Map)
  228.      */
  229.     @Override
  230.     public void extractTermContexts(Map<Term, TermContext> contexts) {
  231.       subWeight.extractTermContexts(contexts);
  232.     }

  234.     /*
  235.      * (non-Javadoc)
  236.      * 
  237.      * @see
  238.      * org.apache.lucene.search.spans.SpanWeight#getSpans(org.apache.lucene.
  239.      * index.LeafReaderContext,
  240.      * org.apache.lucene.search.spans.SpanWeight.Postings)
  241.      */
  242.     @Override
  243.     public Spans getSpans(LeafReaderContext ctx, Postings requiredPostings)
  244.         throws IOException {
  245.       Spans spans = subWeight.getSpans(ctx, requiredPostings);
  246.       if ((maximumLeft == 0 && maximumRight == 0) || spans == null) {
  247.         return spans;
  248.       } else {
  249.         try {
  250.           // get leafreader
  251.           LeafReader r = ctx.reader();
  252.           // get delegate
  253.           Boolean hasMethod = true;
  254.           while (hasMethod) {
  255.             hasMethod = false;
  256.             Method[] methods = r.getClass().getMethods();
  257.             for (Method m : methods) {
  258.               if (m.getName().equals(METHOD_GET_DELEGATE)) {
  259.                 hasMethod = true;
  260.                 r = (LeafReader) m.invoke(r, (Object[]) null);
  261.                 break;
  262.               }
  263.             }
  264.           } // get fieldsproducer
  265.           Method fpm = r.getClass().getMethod(METHOD_GET_POSTINGS_READER,
  266.               (Class<?>[]) null);
  267.           FieldsProducer fp = (FieldsProducer) fpm.invoke(r, (Object[]) null);
  268.           // get MtasFieldsProducer using terms
  269.           Terms t = fp.terms(field);
  270.           if (t == null) {
  271.             return new MtasSpanMatchNoneSpans(MtasMaximumExpandSpanQuery.this);
  272.           } else {
  273.             CodecInfo mtasCodecInfo = CodecInfo.getCodecInfoFromTerms(t);
  274.             return new MtasMaximumExpandSpans(MtasMaximumExpandSpanQuery.this,
  275.                 mtasCodecInfo, query.getField(), spans);
  276.           }
  277.         } catch (Exception e) {
  278.           throw new IOException("Can't get reader", e);
  279.         }

  281.       }
  282.     }

  284.     /*
  285.      * (non-Javadoc)
  286.      * 
  287.      * @see org.apache.lucene.search.Weight#extractTerms(java.util.Set)
  288.      */
  289.     @Override
  290.     public void extractTerms(Set<Term> terms) {
  291.       subWeight.extractTerms(terms);
  292.     }
  293.     
  294. //    @Override
  295. //    public boolean isCacheable(LeafReaderContext arg0) {
  296. //      return subWeight.isCacheable(arg0);
  297. //    }

  299.   }

  301. }
Created with JaCoCo 0.7.9.201702052155