MtasSpanSequenceQuery.java

  1. package mtas.search.spans;

  3. import java.io.IOException;
  4. import java.util.ArrayList;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;

  10. import org.apache.lucene.index.IndexReader;
  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.search.spans.util.MtasExpandSpanQuery;
  20. import mtas.search.spans.util.MtasIgnoreItem;
  21. import mtas.search.spans.util.MtasSpanQuery;
  22. import mtas.search.spans.util.MtasSpanWeight;
  23. import mtas.search.spans.util.MtasSpans;

  25. /**
  26.  * The Class MtasSpanSequenceQuery.
  27.  */
  28. public class MtasSpanSequenceQuery extends MtasSpanQuery {

  30.   /** The items. */
  31.   private List<MtasSpanSequenceItem> items;

  33.   /** The left minimum. */
  34.   private int leftMinimum;

  36.   /** The left maximum. */
  37.   private int leftMaximum;

  39.   /** The right minimum. */
  40.   private int rightMinimum;

  42.   /** The right maximum. */
  43.   private int rightMaximum;

  45.   /** The ignore query. */
  46.   private MtasSpanQuery ignoreQuery;

  48.   /** The maximum ignore length. */
  49.   private Integer maximumIgnoreLength;

  51.   /** The field. */
  52.   private String field;

  54.   /**
  55.    * Instantiates a new mtas span sequence query.
  56.    *
  57.    * @param items the items
  58.    * @param ignoreQuery the ignore query
  59.    * @param maximumIgnoreLength the maximum ignore length
  60.    */
  61.   public MtasSpanSequenceQuery(List<MtasSpanSequenceItem> items,
  62.       MtasSpanQuery ignoreQuery, Integer maximumIgnoreLength) {
  63.     this(items, 0, 0, 0, 0, ignoreQuery, maximumIgnoreLength);
  64.   }

  66.   /**
  67.    * Instantiates a new mtas span sequence query.
  68.    *
  69.    * @param items the items
  70.    * @param leftMinimum the left minimum
  71.    * @param leftMaximum the left maximum
  72.    * @param rightMinimum the right minimum
  73.    * @param rightMaximum the right maximum
  74.    * @param ignoreQuery the ignore query
  75.    * @param maximumIgnoreLength the maximum ignore length
  76.    */
  77.   public MtasSpanSequenceQuery(List<MtasSpanSequenceItem> items,
  78.       int leftMinimum, int leftMaximum, int rightMinimum, int rightMaximum,
  79.       MtasSpanQuery ignoreQuery, Integer maximumIgnoreLength) {
  80.     super(null, null);
  81.     this.items = items;
  82.     this.leftMinimum = leftMinimum;
  83.     this.leftMaximum = leftMaximum;
  84.     this.rightMinimum = rightMinimum;
  85.     this.rightMaximum = rightMaximum;
  86.     // get field and do checks
  87.     Integer minimum = leftMinimum + rightMinimum;
  88.     Integer maximum = leftMaximum + rightMaximum;
  89.     for (MtasSpanSequenceItem item : items) {
  90.       if (field == null) {
  91.         field = item.getQuery().getField();
  92.       } else if (item.getQuery().getField() != null
  93.           && !item.getQuery().getField().equals(field)) {
  94.         throw new IllegalArgumentException("Clauses must have same field.");
  95.       }
  96.       if (minimum != null && !item.isOptional()) {
  97.         minimum = item.getQuery().getMinimumWidth() != null
  98.             ? minimum + item.getQuery().getMinimumWidth() : null;
  99.       }
  100.       if (maximum != null) {
  101.         maximum = item.getQuery().getMaximumWidth() != null
  102.             ? maximum + item.getQuery().getMaximumWidth() : null;
  103.       }
  104.     }
  105.     // check ignore
  106.     if (field != null && ignoreQuery != null) {
  107.       if (ignoreQuery.getField() == null
  108.           || field.equals(ignoreQuery.getField())) {
  109.         this.ignoreQuery = ignoreQuery;
  110.         if (maximumIgnoreLength == null) {
  111.           this.maximumIgnoreLength = MtasIgnoreItem.DEFAULT_MAXIMUM_IGNORE_LENGTH;
  112.         } else {
  113.           this.maximumIgnoreLength = maximumIgnoreLength;
  114.         }
  115.       } else {
  116.         throw new IllegalArgumentException(
  117.             "ignore must have same field as clauses");
  118.       }
  119.       if (maximum != null && items.size() > 1) {
  120.         if (this.ignoreQuery.getMaximumWidth() != null) {
  121.           maximum += (items.size() - 1) * this.maximumIgnoreLength
  122.               * this.ignoreQuery.getMaximumWidth();
  123.         } else {
  124.           maximum = null;
  125.         }
  126.       }
  127.     } else {
  128.       this.ignoreQuery = null;
  129.       this.maximumIgnoreLength = null;
  130.     }
  131.     setWidth(minimum, maximum);
  132.   }

  134.   /*
  135.    * (non-Javadoc)
  136.    * 
  137.    * @see org.apache.lucene.search.spans.SpanQuery#getField()
  138.    */
  139.   @Override
  140.   public String getField() {
  141.     return field;
  142.   }

  144.   /**
  145.    * Gets the items.
  146.    *
  147.    * @return the items
  148.    */
  149.   public List<MtasSpanSequenceItem> getItems() {
  150.     return items;
  151.   }

  153.   /**
  154.    * Gets the ignore query.
  155.    *
  156.    * @return the ignore query
  157.    */
  158.   public MtasSpanQuery getIgnoreQuery() {
  159.     return ignoreQuery;
  160.   }

  162.   /**
  163.    * Gets the maximum ignore length.
  164.    *
  165.    * @return the maximum ignore length
  166.    */
  167.   public Integer getMaximumIgnoreLength() {
  168.     return maximumIgnoreLength;
  169.   }

  171.   /*
  172.    * (non-Javadoc)
  173.    * 
  174.    * @see
  175.    * org.apache.lucene.search.Query#rewrite(org.apache.lucene.index.IndexReader)
  176.    */
  177.   @Override
  178.   public MtasSpanQuery rewrite(IndexReader reader) throws IOException {
  179.     if (items.size() == 1) {
  180.       MtasSpanQuery singleQuery = items.get(0).getQuery();
  181.       if (leftMaximum != 0 || rightMaximum != 0) {
  182.         singleQuery = new MtasExpandSpanQuery(singleQuery, leftMinimum,
  183.             leftMaximum, rightMinimum, rightMaximum);
  184.       }
  185.       return singleQuery.rewrite(reader);
  186.     } else {
  187.       MtasSpanSequenceItem newItem;
  188.       MtasSpanSequenceItem previousNewItem = null;
  189.       ArrayList<MtasSpanSequenceItem> newItems = new ArrayList<>(items.size());
  190.       int newLeftMinimum = leftMinimum;
  191.       int newLeftMaximum = leftMaximum;
  192.       int newRightMinimum = rightMinimum;
  193.       int newRightMaximum = rightMaximum;
  194.       MtasSpanQuery newIgnoreClause = ignoreQuery != null
  195.           ? ignoreQuery.rewrite(reader) : null;
  196.       boolean actuallyRewritten = ignoreQuery != null
  197.           ? !newIgnoreClause.equals(ignoreQuery) : false;
  198.       for (int i = 0; i < items.size(); i++) {
  199.         newItem = items.get(i).rewrite(reader);
  200.         if (newItem.getQuery() instanceof MtasSpanMatchNoneQuery) {
  201.           if (!newItem.isOptional()) {
  202.             return new MtasSpanMatchNoneQuery(field);
  203.           } else {
  204.             actuallyRewritten = true;
  205.           }
  206.         } else {
  207.           actuallyRewritten |= !items.get(i).equals(newItem);
  208.           MtasSpanSequenceItem previousMergedItem = MtasSpanSequenceItem.merge(
  209.               previousNewItem, newItem, ignoreQuery, maximumIgnoreLength);
  210.           if (previousMergedItem != null) {
  211.             newItems.set((newItems.size() - 1), previousMergedItem);
  212.             actuallyRewritten = true;
  213.           } else {
  214.             newItems.add(newItem);
  215.           }
  216.           previousNewItem = newItem;
  217.         }
  218.       }
  219.       // check first and last
  220.       if (ignoreQuery == null) {
  221.         ArrayList<MtasSpanSequenceItem> possibleTrimmedItems = new ArrayList<>(
  222.             newItems.size());
  223.         MtasSpanSequenceItem firstItem = newItems.get(0);
  224.         MtasSpanQuery firstQuery = firstItem.getQuery();
  225.         if (firstQuery instanceof MtasSpanMatchAllQuery) {
  226.           newLeftMaximum++;
  227.           if (!firstItem.isOptional()) {
  228.             newLeftMinimum++;
  229.           }
  230.         } else if (firstQuery instanceof MtasSpanRecurrenceQuery) {
  231.           MtasSpanRecurrenceQuery firstRecurrenceQuery = (MtasSpanRecurrenceQuery) firstQuery;
  232.           if (firstRecurrenceQuery.getQuery() instanceof MtasSpanMatchAllQuery
  233.               && firstRecurrenceQuery.getIgnoreQuery() == null) {
  234.             if (!firstItem.isOptional()) {
  235.               newLeftMinimum += firstRecurrenceQuery.getMinimumRecurrence();
  236.               newLeftMaximum += firstRecurrenceQuery.getMaximumRecurrence();
  237.             } else {
  238.               if (firstRecurrenceQuery.getMinimumRecurrence() == 1
  239.                   || firstRecurrenceQuery
  240.                       .getMinimumRecurrence() <= newLeftMinimum) {
  241.                 newLeftMinimum += 0;
  242.                 newLeftMaximum += firstRecurrenceQuery.getMaximumRecurrence();
  243.               } else {
  244.                 possibleTrimmedItems.add(firstItem);
  245.               }
  246.             }
  247.           } else {
  248.             possibleTrimmedItems.add(firstItem);
  249.           }
  250.         } else {
  251.           possibleTrimmedItems.add(firstItem);
  252.         }
  253.         for (int i = 1; i < (newItems.size() - 1); i++) {
  254.           possibleTrimmedItems.add(newItems.get(i));
  255.         }
  256.         if (newItems.size() > 1) {
  257.           MtasSpanSequenceItem lastItem = newItems.get((newItems.size() - 1));
  258.           MtasSpanQuery lastQuery = lastItem.getQuery();
  259.           if (lastQuery instanceof MtasSpanMatchAllQuery) {
  260.             newRightMaximum++;
  261.             if (!lastItem.isOptional()) {
  262.               newRightMinimum++;
  263.             }
  264.           } else if (lastQuery instanceof MtasSpanRecurrenceQuery) {
  265.             MtasSpanRecurrenceQuery lastRecurrenceQuery = (MtasSpanRecurrenceQuery) lastQuery;
  266.             if (lastRecurrenceQuery.getQuery() instanceof MtasSpanMatchAllQuery
  267.                 && lastRecurrenceQuery.getIgnoreQuery() == null) {
  268.               if (!lastItem.isOptional()) {
  269.                 newRightMinimum += lastRecurrenceQuery.getMinimumRecurrence();
  270.                 newRightMaximum += lastRecurrenceQuery.getMaximumRecurrence();
  271.               } else if (lastRecurrenceQuery.getMinimumRecurrence() == 1
  272.                   || lastRecurrenceQuery
  273.                       .getMinimumRecurrence() <= newRightMinimum) {
  274.                 newRightMinimum += 0;
  275.                 newRightMaximum += lastRecurrenceQuery.getMaximumRecurrence();
  276.               } else {
  277.                 possibleTrimmedItems.add(lastItem);
  278.               }
  279.             } else {
  280.               possibleTrimmedItems.add(lastItem);
  281.             }
  282.           } else {
  283.             possibleTrimmedItems.add(lastItem);
  284.           }
  285.         }
  286.         if (possibleTrimmedItems.size() < newItems.size()) {
  287.           actuallyRewritten = true;
  288.           newItems = possibleTrimmedItems;
  289.         }
  290.       }
  291.       if (!actuallyRewritten) {
  292.         if (leftMaximum != 0 || rightMaximum != 0) {
  293.           newLeftMinimum = leftMinimum;
  294.           newLeftMaximum = leftMaximum;
  295.           newRightMinimum = rightMinimum;
  296.           newRightMaximum = rightMaximum;
  297.           leftMinimum = 0;
  298.           leftMaximum = 0;
  299.           rightMinimum = 0;
  300.           rightMaximum = 0;
  301.           MtasSpanQuery finalQuery = new MtasExpandSpanQuery(this,
  302.               newLeftMinimum, newLeftMaximum, newRightMinimum, newRightMaximum);
  303.           return finalQuery.rewrite(reader);
  304.         } else {
  305.           return super.rewrite(reader);
  306.         }
  307.       } else {
  308.         if (!newItems.isEmpty()) {
  309.           return new MtasSpanSequenceQuery(newItems, newLeftMinimum,
  310.               newLeftMaximum, newRightMinimum, newRightMaximum, newIgnoreClause,
  311.               maximumIgnoreLength).rewrite(reader);
  312.         } else {
  313.           return new MtasSpanMatchNoneQuery(field);
  314.         }
  315.       }
  316.     }
  317.   }

  319.   /*
  320.    * (non-Javadoc)
  321.    * 
  322.    * @see org.apache.lucene.search.Query#toString(java.lang.String)
  323.    */
  324.   @Override
  325.   public String toString(String field) {
  326.     StringBuilder buffer = new StringBuilder();
  327.     buffer.append(this.getClass().getSimpleName() + "([");
  328.     Iterator<MtasSpanSequenceItem> i = items.iterator();
  329.     while (i.hasNext()) {
  330.       MtasSpanSequenceItem item = i.next();
  331.       MtasSpanQuery clause = item.getQuery();
  332.       buffer.append(clause.toString(field));
  333.       if (item.isOptional()) {
  334.         buffer.append("{OPTIONAL}");
  335.       }
  336.       if (i.hasNext()) {
  337.         buffer.append(", ");
  338.       }
  339.     }
  340.     buffer.append("[" + leftMinimum + "," + leftMaximum + "]");
  341.     buffer.append("[" + rightMinimum + "," + rightMaximum + "]");
  342.     buffer.append("]");
  343.     buffer.append(", ");
  344.     buffer.append(ignoreQuery);
  345.     buffer.append(")");
  346.     return buffer.toString();
  347.   }

  349.   /*
  350.    * (non-Javadoc)
  351.    * 
  352.    * @see org.apache.lucene.search.Query#equals(java.lang.Object)
  353.    */
  354.   @Override
  355.   public boolean equals(Object obj) {
  356.     if (this == obj)
  357.       return true;
  358.     if (obj == null)
  359.       return false;
  360.     if (getClass() != obj.getClass())
  361.       return false;
  362.     MtasSpanSequenceQuery other = (MtasSpanSequenceQuery) obj;
  363.     boolean isEqual;
  364.     isEqual = field.equals(other.field);
  365.     isEqual &= items.equals(other.items);
  366.     isEqual &= leftMinimum == other.leftMinimum;
  367.     isEqual &= leftMaximum == other.leftMaximum;
  368.     isEqual &= rightMinimum == other.rightMinimum;
  369.     isEqual &= rightMaximum == other.rightMaximum;
  370.     isEqual &= ((ignoreQuery == null && other.ignoreQuery == null)
  371.         || (ignoreQuery != null && other.ignoreQuery != null
  372.             && ignoreQuery.equals(other.ignoreQuery)));
  373.     return isEqual;
  374.   }

  376.   /*
  377.    * (non-Javadoc)
  378.    * 
  379.    * @see org.apache.lucene.search.Query#hashCode()
  380.    */
  381.   @Override
  382.   public int hashCode() {
  383.     int h = this.getClass().getSimpleName().hashCode();
  384.     h = (h * 3) ^ field.hashCode();
  385.     h = (h * 5) ^ items.hashCode();
  386.     h = Integer.rotateLeft(h, leftMinimum) + leftMinimum;
  387.     h ^= 11;
  388.     h = Integer.rotateLeft(h, leftMaximum) + leftMaximum;
  389.     h ^= 13;
  390.     h = Integer.rotateLeft(h, rightMinimum) + rightMinimum;
  391.     h ^= 17;
  392.     h = Integer.rotateLeft(h, rightMaximum) + rightMaximum;
  393.     if (ignoreQuery != null) {
  394.       h = (h * 7) ^ ignoreQuery.hashCode();
  395.       h = (h * 11) ^ maximumIgnoreLength.hashCode();
  396.     }
  397.     return h;
  398.   }

  400.   /*
  401.    * (non-Javadoc)
  402.    * 
  403.    * @see
  404.    * org.apache.lucene.search.spans.SpanQuery#createWeight(org.apache.lucene.
  405.    * search.IndexSearcher, boolean)
  406.    */
  407.   @Override
  408.   public MtasSpanWeight createWeight(IndexSearcher searcher,
  409.       boolean needsScores, float boost) throws IOException {
  410.     List<MtasSpanSequenceQueryWeight> subWeights = new ArrayList<>();
  411.     SpanWeight ignoreWeight = null;
  412.     for (MtasSpanSequenceItem item : items) {
  413.       subWeights.add(new MtasSpanSequenceQueryWeight(
  414.           item.getQuery().createWeight(searcher, false, boost), item.isOptional()));
  415.     }
  416.     if (ignoreQuery != null) {
  417.       ignoreWeight = ignoreQuery.createWeight(searcher, false, boost);
  418.     }
  419.     return new SpanSequenceWeight(subWeights, ignoreWeight, maximumIgnoreLength,
  420.         searcher, needsScores ? getTermContexts(subWeights) : null, boost);
  421.   }

  423.   /**
  424.    * Gets the term contexts.
  425.    *
  426.    * @param items the items
  427.    * @return the term contexts
  428.    */
  429.   protected Map<Term, TermContext> getTermContexts(
  430.       List<MtasSpanSequenceQueryWeight> items) {
  431.     List<SpanWeight> weights = new ArrayList<>();
  432.     for (MtasSpanSequenceQueryWeight item : items) {
  433.       weights.add(item.spanWeight);
  434.     }
  435.     return getTermContexts(weights);
  436.   }

  438.   /*
  439.    * (non-Javadoc)
  440.    * 
  441.    * @see mtas.search.spans.util.MtasSpanQuery#disableTwoPhaseIterator()
  442.    */
  443.   @Override
  444.   public void disableTwoPhaseIterator() {
  445.     super.disableTwoPhaseIterator();
  446.     for (MtasSpanSequenceItem item : items) {
  447.       item.getQuery().disableTwoPhaseIterator();
  448.     }
  449.     if (ignoreQuery != null) {
  450.       ignoreQuery.disableTwoPhaseIterator();
  451.     }
  452.   }

  454.   /**
  455.    * The Class SpanSequenceWeight.
  456.    */
  457.   protected class SpanSequenceWeight extends MtasSpanWeight {

  459.     /** The sub weights. */
  460.     final List<MtasSpanSequenceQueryWeight> subWeights;

  462.     /** The ignore weight. */
  463.     final SpanWeight ignoreWeight;

  465.     /** The maximum ignore length. */
  466.     final Integer maximumIgnoreLength;

  468.     /**
  469.      * Instantiates a new span sequence weight.
  470.      *
  471.      * @param subWeights the sub weights
  472.      * @param ignoreWeight the ignore weight
  473.      * @param maximumIgnoreLength the maximum ignore length
  474.      * @param searcher the searcher
  475.      * @param terms the terms
  476.      * @throws IOException Signals that an I/O exception has occurred.
  477.      */
  478.     public SpanSequenceWeight(List<MtasSpanSequenceQueryWeight> subWeights,
  479.         SpanWeight ignoreWeight, Integer maximumIgnoreLength,
  480.         IndexSearcher searcher, Map<Term, TermContext> terms, float boost)
  481.         throws IOException {
  482.       super(MtasSpanSequenceQuery.this, searcher, terms, boost);
  483.       this.subWeights = subWeights;
  484.       this.ignoreWeight = ignoreWeight;
  485.       this.maximumIgnoreLength = maximumIgnoreLength;
  486.     }

  488.     /*
  489.      * (non-Javadoc)
  490.      * 
  491.      * @see
  492.      * org.apache.lucene.search.spans.SpanWeight#extractTermContexts(java.util.
  493.      * Map)
  494.      */
  495.     @Override
  496.     public void extractTermContexts(Map<Term, TermContext> contexts) {
  497.       for (MtasSpanSequenceQueryWeight w : subWeights) {
  498.         w.spanWeight.extractTermContexts(contexts);
  499.       }
  500.       if (ignoreWeight != null) {
  501.         ignoreWeight.extractTermContexts(contexts);
  502.       }
  503.     }

  505.     /*
  506.      * (non-Javadoc)
  507.      * 
  508.      * @see
  509.      * org.apache.lucene.search.spans.SpanWeight#getSpans(org.apache.lucene.
  510.      * index.LeafReaderContext,
  511.      * org.apache.lucene.search.spans.SpanWeight.Postings)
  512.      */
  513.     @Override
  514.     public MtasSpans getSpans(LeafReaderContext context,
  515.         Postings requiredPostings) throws IOException {
  516.       if (field == null) {
  517.         return null;
  518.       } else {
  519.         Terms terms = context.reader().terms(field);
  520.         if (terms == null) {
  521.           return null; // field does not exist
  522.         }
  523.         List<MtasSpanSequenceQuerySpans> setSequenceSpans = new ArrayList<>(
  524.             items.size());
  525.         Spans ignoreSpans = null;
  526.         boolean allSpansEmpty = true;
  527.         for (MtasSpanSequenceQueryWeight w : subWeights) {
  528.           Spans sequenceSpans = w.spanWeight.getSpans(context,
  529.               requiredPostings);
  530.           if (sequenceSpans != null) {
  531.             setSequenceSpans.add(new MtasSpanSequenceQuerySpans(
  532.                 MtasSpanSequenceQuery.this, sequenceSpans, w.optional));
  533.             allSpansEmpty = false;
  534.           } else {
  535.             if (w.optional) {
  536.               setSequenceSpans.add(new MtasSpanSequenceQuerySpans(
  537.                   MtasSpanSequenceQuery.this, null, w.optional));
  538.             } else {
  539.               return null;
  540.             }
  541.           }
  542.         }
  543.         if (allSpansEmpty) {
  544.           return null; // at least one required
  545.         } else if (ignoreWeight != null) {
  546.           ignoreSpans = ignoreWeight.getSpans(context, requiredPostings);
  547.         }
  548.         return new MtasSpanSequenceSpans(MtasSpanSequenceQuery.this,
  549.             setSequenceSpans, ignoreSpans, maximumIgnoreLength);
  550.       }
  551.     }

  553.     /*
  554.      * (non-Javadoc)
  555.      * 
  556.      * @see org.apache.lucene.search.Weight#extractTerms(java.util.Set)
  557.      */
  558.     @Override
  559.     public void extractTerms(Set<Term> terms) {
  560.       for (MtasSpanSequenceQueryWeight w : subWeights) {
  561.         w.spanWeight.extractTerms(terms);
  562.       }
  563.       if (ignoreWeight != null) {
  564.         ignoreWeight.extractTerms(terms);
  565.       }
  566.     }
  567.     
  568. //    @Override
  569. //    public boolean isCacheable(LeafReaderContext arg0) {      
  570. //      for(MtasSpanSequenceQueryWeight sqw : subWeights) {
  571. //        if(!sqw.spanWeight.isCacheable(arg0)) {
  572. //          return false;
  573. //        }
  574. //      }
  575. //      if(ignoreWeight!=null) {
  576. //        return ignoreWeight.isCacheable(arg0);
  577. //      }
  578. //      return true;            
  579. //    }

  581.   }

  583.   /**
  584.    * The Class MtasSpanSequenceQuerySpans.
  585.    */
  586.   protected static class MtasSpanSequenceQuerySpans {

  588.     /** The spans. */
  589.     public Spans spans;

  591.     /** The optional. */
  592.     public boolean optional;

  594.     /**
  595.      * Instantiates a new mtas span sequence query spans.
  596.      *
  597.      * @param query the query
  598.      * @param spans the spans
  599.      * @param optional the optional
  600.      */
  601.     public MtasSpanSequenceQuerySpans(MtasSpanSequenceQuery query, Spans spans,
  602.         boolean optional) {
  603.       this.spans = spans != null ? spans : new MtasSpanMatchNoneSpans(query);
  604.       this.optional = optional;
  605.     }
  606.   }

  608.   /**
  609.    * The Class MtasSpanSequenceQueryWeight.
  610.    */
  611.   private static class MtasSpanSequenceQueryWeight {

  613.     /** The span weight. */
  614.     public SpanWeight spanWeight;

  616.     /** The optional. */
  617.     public boolean optional;

  619.     /**
  620.      * Instantiates a new mtas span sequence query weight.
  621.      *
  622.      * @param spanWeight the span weight
  623.      * @param optional the optional
  624.      */
  625.     public MtasSpanSequenceQueryWeight(SpanWeight spanWeight,
  626.         boolean optional) {
  627.       this.spanWeight = spanWeight;
  628.       this.optional = optional;
  629.     }
  630.   }
  631.   
  632.   @Override
  633.   public boolean isMatchAllPositionsQuery() {
  634.     return false;
  635.   }

  637. }
Created with JaCoCo 0.7.9.201702052155