Examples of BooleanFilter

autotest.common.table.BooleanFilter
ch.ralscha.extdirectspring.filter.BooleanFilter
com.extjs.gxt.ui.client.widget.grid.filters.BooleanFilter
Boolean filter that displays yes / no radio items.
com.flaptor.hounder.searcher.filter.BooleanFilter
Implement a Filter that is the rusult of ANDing a series of filters. This class is "immutable", but only after the first use of getLuceneFilter. This class is not thread safe. This filter is not cached on it's own, but the filters passed to it may be cached. There would be little gain in caching this class, as it does't generate a lucene filter with it's associated lengthy bitArray.
org.apache.lucene.queries.BooleanFilter
A container Filter that allows Boolean composition of Filters. Filters are allocated into one of three logical constructs; SHOULD, MUST NOT, MUST The results Filter BitSet is constructed as follows: SHOULD Filters are OR'd together The resulting Filter is NOT'd with the NOT Filters The resulting Filter is AND'd with the MUST Filters
org.apache.lucene.search.BooleanFilter
A container Filter that allows Boolean composition of Filters. Filters are allocated into one of three logical constructs; SHOULD, MUST NOT, MUST The results Filter BitSet is constructed as follows: SHOULD Filters are OR'd together The resulting Filter is NOT'd with the NOT Filters The resulting Filter is AND'd with the MUST Filters

Examples of autotest.common.table.BooleanFilter


        hostnameFilter = new SearchFilter("hostname", true);
        labelFilter = new LabelFilter();
        statusFilter = new ListFilter("status");
        statusFilter.setChoices(statusStrings);
        lockedFilter = new BooleanFilter("locked");
        lockedByFilter = new ListFilter("locked_by__login");
        lockedByFilter.setChoices(userStrings.toArray(new String[userStrings.size()]));
        aclFilter = new AclAccessibleFilter();
        excludeAtomicGroupsFilter = new AtomicGroupFilter();

View Full Code Here

Examples of ch.ralscha.extdirectspring.filter.BooleanFilter

    }
    case 3: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);


      BooleanFilter bf1 = (BooleanFilter) filters.get(0);
      assertThat(bf1.getValue()).isEqualTo(true);
      assertThat(bf1.getField()).isEqualTo("visible");


      BooleanFilter bf2 = request.getFirstFilterForField("visible");
      assertThat(bf2).isSameAs(bf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
      assertThat(allFiltersForField).containsExactly(bf1);


      assertThat(request.getFirstFilterForField("xy")).isNull();
      assertThat(request.getAllFiltersForField("xy")).isEmpty();


      return createResult(type);
    }
    case 4: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);


      BooleanFilter bf1 = (BooleanFilter) filters.get(0);
      assertThat(bf1.getValue()).isEqualTo(false);
      assertThat(bf1.getField()).isEqualTo("visible");


      BooleanFilter bf2 = request.getFirstFilterForField("visible");
      assertThat(bf2).isSameAs(bf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
      assertThat(allFiltersForField).containsExactly(bf1);


      return createResult(type);
    }
    case 5: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(StringFilter.class);


      StringFilter sf1 = (StringFilter) filters.get(0);
      assertThat(sf1.getValue()).isEqualTo("abb");
      assertThat(sf1.getField()).isEqualTo("company");


      StringFilter sf2 = request.getFirstFilterForField("company");
      assertThat(sf2).isSameAs(sf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("company");
      assertThat(allFiltersForField).containsExactly(sf1);


      return createResult(type);
    }
    case 6: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(ListFilter.class);


      ListFilter<String> lf1 = (ListFilter) filters.get(0);
      assertThat(lf1.getValue().size()).isEqualTo(1);
      assertThat(lf1.getValue().get(0)).isEqualTo("small");
      assertThat(lf1.getField()).isEqualTo("size");


      ListFilter<String> lf2 = request.getFirstFilterForField("size");
      assertThat(lf2).isSameAs(lf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("size");
      assertThat(allFiltersForField).containsExactly(lf1);


      return createResult(type);
    }
    case 7: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(ListFilter.class);


      ListFilter<String> lf1 = (ListFilter) filters.get(0);
      assertThat(lf1.getValue().size()).isEqualTo(2);
      assertThat(lf1.getValue().get(0)).isEqualTo("small");
      assertThat(lf1.getValue().get(1)).isEqualTo("medium");
      assertThat(lf1.getField()).isEqualTo("size");


      ListFilter<String> lf2 = request.getFirstFilterForField("size");
      assertThat(lf2).isSameAs(lf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("size");
      assertThat(allFiltersForField).containsExactly(lf1);


      return createResult(type);
    }
    case 8:
    case 17: {
      assertThat(filters).hasSize(2);
      assertThat(filters.get(0)).isInstanceOf(DateFilter.class);
      assertThat(filters.get(1)).isInstanceOf(DateFilter.class);


      DateFilter df = (DateFilter) filters.get(0);
      assertThat(df.getValue()).isEqualTo("07/31/2010");
      assertThat(df.getField()).isEqualTo("date");
      assertThat(df.getComparison()).isEqualTo(Comparison.LESS_THAN);


      if (type == 17) {
        assertThat(df.getRawComparison()).isEqualTo("<");
      }
      else {
        assertThat(df.getRawComparison()).isEqualTo("lt");
      }


      df = (DateFilter) filters.get(1);
      assertThat(df.getValue()).isEqualTo("07/01/2010");
      assertThat(df.getField()).isEqualTo("date");
      assertThat(df.getComparison()).isEqualTo(Comparison.GREATER_THAN);
      if (type == 17) {
        assertThat(df.getRawComparison()).isEqualTo(">");
      }
      else {
        assertThat(df.getRawComparison()).isEqualTo("gt");
      }


      DateFilter df2 = request.getFirstFilterForField("date");
      assertThat(df2).isSameAs((DateFilter) filters.get(0));


      List<Filter> allFiltersForField = request.getAllFiltersForField("date");
      assertThat(allFiltersForField)
          .containsExactly(filters.get(0), filters.get(1));


      return createResult(type);
    }
    case 9:
    case 18: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(DateFilter.class);


      DateFilter df1 = (DateFilter) filters.get(0);
      assertThat(df1.getValue()).isEqualTo("07/01/2010");
      assertThat(df1.getField()).isEqualTo("date");
      assertThat(df1.getComparison()).isEqualTo(Comparison.EQUAL);
      if (type == 18) {
        assertThat(df1.getRawComparison()).isEqualTo("=");
      }
      else {
        assertThat(df1.getRawComparison()).isEqualTo("eq");
      }


      DateFilter df2 = request.getFirstFilterForField("date");
      assertThat(df2).isSameAs(df1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("date");
      assertThat(allFiltersForField).containsExactly(df1);


      return createResult(type);
    }
    case 10: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(StringFilter.class);


      StringFilter sf1 = (StringFilter) filters.get(0);
      assertThat(sf1.getValue()).isEqualTo("ERROR");
      assertThat(sf1.getField()).isEqualTo("level");


      StringFilter sf2 = request.getFirstFilterForField("level");
      assertThat(sf2).isSameAs(sf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("level");
      assertThat(allFiltersForField).containsExactly(sf1);


      return createResult(type);
    }
    case 11: {
      assertThat(request.getFilters()).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);


      NumericFilter nf1 = (NumericFilter) filters.get(0);
      assertThat(nf1.getValue()).isEqualTo(1);
      assertThat(nf1.getField()).isEqualTo("level");
      assertThat(nf1.getComparison()).isNull();
      assertThat(nf1.getRawComparison()).isNull();


      NumericFilter nf2 = request.getFirstFilterForField("level");
      assertThat(nf2).isSameAs(nf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("level");
      assertThat(allFiltersForField).containsExactly(nf1);


      return createResult(type);
    }
    case 12: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);


      BooleanFilter bf1 = (BooleanFilter) filters.get(0);
      assertThat(bf1.getValue()).isEqualTo(true);
      assertThat(bf1.getField()).isEqualTo("level");


      BooleanFilter bf2 = request.getFirstFilterForField("level");
      assertThat(bf2).isSameAs(bf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("level");
      assertThat(allFiltersForField).containsExactly(bf1);


      return createResult(type);
    }
    case 13: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(ListFilter.class);


      ListFilter<String> lf1 = (ListFilter) filters.get(0);
      assertThat(lf1.getValue().size()).isEqualTo(1);
      assertThat(lf1.getValue().get(0)).isEqualTo("small");
      assertThat(lf1.getField()).isEqualTo("size");


      ListFilter<String> lf2 = request.getFirstFilterForField("size");
      assertThat(lf2).isSameAs(lf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("size");
      assertThat(allFiltersForField).containsExactly(lf1);


      return createResult(type);
    }
    case 14: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(ListFilter.class);


      ListFilter<String> lf1 = (ListFilter) filters.get(0);
      assertThat(lf1.getValue().size()).isEqualTo(2);
      assertThat(lf1.getValue().get(0)).isEqualTo("small");
      assertThat(lf1.getValue().get(1)).isEqualTo("medium");
      assertThat(lf1.getField()).isEqualTo("size");


      ListFilter<String> lf2 = request.getFirstFilterForField("size");
      assertThat(lf2).isSameAs(lf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("size");
      assertThat(allFiltersForField).containsExactly(lf1);


      return createResult(type);
    }
    case 19: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(StringFilter.class);


      StringFilter sf1 = (StringFilter) filters.get(0);
      assertThat(sf1.getValue()).isNull();
      assertThat(sf1.getField()).isEqualTo("name");


      StringFilter sf2 = request.getFirstFilterForField("name");
      assertThat(sf2).isSameAs(sf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("name");
      assertThat(allFiltersForField).containsExactly(sf1);


      return createResult(type);
    }
    case 20: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(StringFilter.class);


      StringFilter sf1 = (StringFilter) filters.get(0);
      assertThat(sf1.getValue()).isNull();
      assertThat(sf1.getField()).isEqualTo("firstname");


      StringFilter sf2 = request.getFirstFilterForField("firstname");
      assertThat(sf2).isSameAs(sf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("firstname");
      assertThat(allFiltersForField).containsExactly(sf1);


      return createResult(type);
    }
    case 21: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(StringFilter.class);


      StringFilter sf1 = (StringFilter) filters.get(0);
      assertThat(sf1.getValue()).isNull();
      assertThat(sf1.getField()).isEqualTo("firstname");


      StringFilter sf2 = request.getFirstFilterForField("firstname");
      assertThat(sf2).isSameAs(sf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("firstname");
      assertThat(allFiltersForField).containsExactly(sf1);


      return createResult(type);
    }
    case 22: {
      assertThat(request.getFilters()).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);


      NumericFilter nf = (NumericFilter) filters.get(0);
      assertThat(nf.getValue()).isEqualTo(2);
      assertThat(nf.getField()).isEqualTo("id");
      assertThat(nf.getComparison()).isEqualTo(Comparison.EQUAL);
      assertThat(nf.getRawComparison()).isEqualTo("eq");


      NumericFilter nf2 = request.getFirstFilterForField("id");
      assertThat(nf2).isSameAs(nf);


      List<Filter> allFiltersForField = request.getAllFiltersForField("id");
      assertThat(allFiltersForField).hasSize(1);
      Filter nf3 = allFiltersForField.iterator().next();
      assertThat(nf3).isInstanceOf(NumericFilter.class);
      assertThat(nf3).isSameAs(nf);


      assertThat(request.getFirstFilterForField("xy")).isNull();
      assertThat(request.getAllFiltersForField("xy")).isEmpty();


      assertThat(request.getSorters()).hasSize(1);
      SortInfo sortInfo = request.getSorters().iterator().next();
      assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
      assertThat(sortInfo.getProperty()).isEqualTo("company");


      return createResult(type);
    }
    case 23: {
      assertThat(request.getFilters()).hasSize(2);
      assertThat(filters.get(0)).isInstanceOf(NumericFilter.class);
      assertThat(filters.get(1)).isInstanceOf(NumericFilter.class);


      NumericFilter nf = (NumericFilter) filters.get(0);
      assertThat(nf.getValue()).isEqualTo(100);
      assertThat(nf.getField()).isEqualTo("id");
      assertThat(nf.getComparison()).isEqualTo(Comparison.LESS_THAN);
      assertThat(nf.getRawComparison()).isEqualTo("lt");


      nf = (NumericFilter) filters.get(1);
      assertThat(nf.getValue()).isEqualTo(90);
      assertThat(nf.getField()).isEqualTo("id");
      assertThat(nf.getComparison()).isEqualTo(Comparison.GREATER_THAN);
      assertThat(nf.getRawComparison()).isEqualTo("gt");


      NumericFilter nf2 = request.getFirstFilterForField("id");
      assertThat(nf2).isSameAs((NumericFilter) filters.get(0));


      List<Filter> allFiltersForField = request.getAllFiltersForField("id");
      assertThat(allFiltersForField)
          .containsExactly(filters.get(0), filters.get(1));


      assertThat(request.getFirstFilterForField("xy")).isNull();
      assertThat(request.getAllFiltersForField("xy")).isEmpty();


      assertThat(request.getSorters()).hasSize(1);
      SortInfo sortInfo = request.getSorters().iterator().next();
      assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
      assertThat(sortInfo.getProperty()).isEqualTo("company");


      return createResult(type);
    }
    case 24: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);


      BooleanFilter bf1 = (BooleanFilter) filters.get(0);
      assertThat(bf1.getValue()).isEqualTo(true);
      assertThat(bf1.getField()).isEqualTo("visible");
      assertThat(bf1.getComparison()).isEqualTo(Comparison.EQUAL);
      assertThat(bf1.getRawComparison()).isEqualTo("=");


      BooleanFilter bf2 = request.getFirstFilterForField("visible");
      assertThat(bf2).isSameAs(bf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
      assertThat(allFiltersForField).containsExactly(bf1);


      assertThat(request.getFirstFilterForField("xy")).isNull();
      assertThat(request.getAllFiltersForField("xy")).isEmpty();


      assertThat(request.getSorters()).hasSize(1);
      SortInfo sortInfo = request.getSorters().iterator().next();
      assertThat(sortInfo.getDirection()).isEqualTo(SortDirection.ASCENDING);
      assertThat(sortInfo.getProperty()).isEqualTo("company");


      return createResult(type);
    }
    case 25: {
      assertThat(filters).hasSize(1);
      assertThat(filters.get(0)).isInstanceOf(BooleanFilter.class);


      BooleanFilter bf1 = (BooleanFilter) filters.get(0);
      assertThat(bf1.getValue()).isEqualTo(false);
      assertThat(bf1.getField()).isEqualTo("visible");
      assertThat(bf1.getComparison()).isEqualTo(Comparison.EQUAL);
      assertThat(bf1.getRawComparison()).isEqualTo("=");


      BooleanFilter bf2 = request.getFirstFilterForField("visible");
      assertThat(bf2).isSameAs(bf1);


      List<Filter> allFiltersForField = request.getAllFiltersForField("visible");
      assertThat(allFiltersForField).containsExactly(bf1);

View Full Code Here

Examples of com.extjs.gxt.ui.client.widget.grid.filters.BooleanFilter


    NumericFilter last = new NumericFilter("last");
    NumericFilter filter = new NumericFilter("change");
    StringFilter nameFilter = new StringFilter("name");
    DateFilter dateFilter = new DateFilter("date");
    BooleanFilter booleanFilter = new BooleanFilter("split");


    ListStore<ModelData> typeStore = new ListStore<ModelData>();
    typeStore.add(type("Auto"));
    typeStore.add(type("Media"));
    typeStore.add(type("Medical"));

View Full Code Here

Examples of com.extjs.gxt.ui.client.widget.grid.filters.BooleanFilter

    GridFilters filters = new GridFilters();
    NumericFilter last = new NumericFilter("last");
    NumericFilter filter = new NumericFilter("change");
    StringFilter nameFilter = new StringFilter("name");
    DateFilter dateFilter = new DateFilter("date");
    BooleanFilter booleanFilter = new BooleanFilter("split");


    ListStore<ModelData> typeStore = new ListStore<ModelData>();
    typeStore.add(type("Auto"));
    typeStore.add(type("Media"));
    typeStore.add(type("Medical"));

View Full Code Here

Examples of com.flaptor.hounder.searcher.filter.BooleanFilter

   */
  protected AFilter generateFilters(final Vector filters) {
    if (null == filters) {
      return null;
    } else {
      BooleanFilter andedFilter = new BooleanFilter(BooleanFilter.Type.AND);
      int filterCounter = 0;
      for (Iterator iter = filters.iterator(); iter.hasNext();) {
        List filter;
        try {
          filter = (Vector) iter.next();
        } catch (ClassCastException e) {
          String s = "generateFilters: the outer list contains an object that is not a list." + e;
          logger.error(s);
          throw new IllegalArgumentException(s);
        }
        int stringCounter = 0;
        String[] s = new String[3];
        for (Iterator iter2 = filter.iterator(); iter2.hasNext();) {
          try {
            s[stringCounter] = (String) iter2.next();
          } catch (ClassCastException e) {
            String m = "generateFilters: the inner list " + filterCounter + " contains a non String object at position " + stringCounter;
            logger.error(m);
            throw new IllegalArgumentException(m);
          }
          stringCounter++;
          if (stringCounter > 2) {
            break;
          }
        }
        if (stringCounter == 2) {
          andedFilter.addFilter(new ValueFilter(s[0], s[1]));
        } else if (stringCounter == 3) {
          andedFilter.addFilter(new RangeFilter(s[0], s[1], s[2]));
        } else {
          String m = "generateFilters: inner list number " + filterCounter + " contains " + stringCounter + " strings.";
          logger.error(m);
          throw new IllegalArgumentException(m);
        }

View Full Code Here

Examples of com.flaptor.hounder.searcher.filter.BooleanFilter


        // Filtering


        // Categories (multi-valued)
        String[] categoriesParams = params.get("categories");
        BooleanFilter andFilter = null;
        if (categoriesParams != null) {
            andFilter = new BooleanFilter(BooleanFilter.Type.AND);
            for (String categoriesParam : categoriesParams) {
                String[] oredCategories = categoriesParam.split(",");
                BooleanFilter orFilter = new BooleanFilter(BooleanFilter.Type.OR);
                for (String oredCategory : oredCategories) {
                    orFilter.addFilter(new ValueFilter("categories", oredCategory));
                }
                andFilter.addFilter(orFilter);
            }
        }

View Full Code Here

Examples of com.flaptor.hounder.searcher.filter.BooleanFilter


        // Filtering


        // Categories (multi-valued)
        String[] categoriesParams = params.get("categories");
        BooleanFilter andFilter = null;
        if (categoriesParams != null) {
            andFilter = new BooleanFilter(BooleanFilter.Type.AND);
            for (String categoriesParam : categoriesParams) {
                String[] oredCategories = categoriesParam.split(",");
                BooleanFilter orFilter = new BooleanFilter(BooleanFilter.Type.OR);
                for (String oredCategory : oredCategories) {
                    orFilter.addFilter(new ValueFilter("categories", oredCategory));
                }
                andFilter.addFilter(orFilter);
            }
        }


        // Site (uni-valued)
        String siteParam = getParameter(params,"site");
        if (siteParam != null) {
            if (andFilter == null) {
                andFilter = new BooleanFilter(BooleanFilter.Type.AND);
            }
            andFilter.addFilter(new ValueFilter("site", siteParam));
        }


        // Crawl (multi-valued)
        String[] crawlParams = params.get("crawl");
        if (crawlParams != null) {
            if (andFilter == null) {
                andFilter = new BooleanFilter(BooleanFilter.Type.AND);
            }
            for (String crawlParam : crawlParams) {
                String[] oredCrawls = crawlParam.split(",");
                BooleanFilter orFilter = new BooleanFilter(BooleanFilter.Type.OR);
                for (String oredCrawl : oredCrawls) {
                    orFilter.addFilter(new ValueFilter("crawl", oredCrawl));
                }
                andFilter.addFilter(orFilter);
            }
        }

View Full Code Here

Examples of org.apache.lucene.queries.BooleanFilter

      maxLat = Math.min(maxLat, Math.toRadians(90));
      minLng = Math.toRadians(-180);
      maxLng = Math.toRadians(180);
    }


    BooleanFilter f = new BooleanFilter();


    // Add latitude range filter:
    f.add(NumericRangeFilter.newDoubleRange("latitude", Math.toDegrees(minLat), Math.toDegrees(maxLat), true, true),
          BooleanClause.Occur.MUST);


    // Add longitude range filter:
    if (minLng > maxLng) {
      // The bounding box crosses the international date
      // line:
      BooleanFilter lonF = new BooleanFilter();
      lonF.add(NumericRangeFilter.newDoubleRange("longitude", Math.toDegrees(minLng), null, true, true),
               BooleanClause.Occur.SHOULD);
      lonF.add(NumericRangeFilter.newDoubleRange("longitude", null, Math.toDegrees(maxLng), true, true),
               BooleanClause.Occur.SHOULD);
      f.add(lonF, BooleanClause.Occur.MUST);
    } else {
      f.add(NumericRangeFilter.newDoubleRange("longitude", Math.toDegrees(minLng), Math.toDegrees(maxLng), true, true),
            BooleanClause.Occur.MUST);

View Full Code Here

Examples of org.apache.lucene.queries.BooleanFilter

      } else if (recordFilterForSearch != null && readFilter == null) {
        docFilter = recordFilterForSearch;
      } else if (recordFilterForSearch != null && readFilter != null) {
        // @TODO dangerous call because of the bitsets that booleanfilter
        // creates.
        BooleanFilter booleanFilter = new BooleanFilter();
        booleanFilter.add(recordFilterForSearch, Occur.MUST);
        booleanFilter.add(readFilter, Occur.MUST);
        docFilter = booleanFilter;
      } else {
        docFilter = null;
      }
      Query userQuery = QueryParserUtil.parseQuery(simpleQuery.query, simpleQuery.rowQuery, fieldManager,

View Full Code Here

Examples of org.apache.lucene.queries.BooleanFilter


  private Filter buildNewFilter(Query query, ConcurrentMap<String, String> filterAlias, FilterParser filterParser)
      throws ParseException {
    if (query instanceof BooleanQuery) {
      BooleanQuery booleanQuery = (BooleanQuery) query;
      BooleanFilter booleanFilter = new BooleanFilter();
      for (BooleanClause clause : booleanQuery.clauses()) {
        booleanFilter.add(buildNewFilter(clause.getQuery(), filterAlias, filterParser), clause.getOccur());
      }
      return booleanFilter;
    } else if (query instanceof TermQuery) {
      TermQuery termQuery = (TermQuery) query;
      Term term = termQuery.getTerm();

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.