Java FacetArrays类代码示例

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
static TotalFacetCounts compute(final IndexReader indexReader, final TaxonomyReader taxonomy, 
    final FacetIndexingParams facetIndexingParams) throws IOException {
  int partitionSize = PartitionsUtils.partitionSize(facetIndexingParams, taxonomy);
  final int[][] counts = new int[(int) Math.ceil(taxonomy.getSize()  /(float) partitionSize)][partitionSize];
  FacetSearchParams newSearchParams = new FacetSearchParams(facetIndexingParams, DUMMY_REQ); 
    //createAllListsSearchParams(facetIndexingParams,  this.totalCounts);
  StandardFacetsAccumulator sfa = new StandardFacetsAccumulator(newSearchParams, indexReader, taxonomy) {
    @Override
    protected HashMap<CategoryListIterator, Aggregator> getCategoryListMap(
        FacetArrays facetArrays, int partition) throws IOException {
      
      Aggregator aggregator = new CountingAggregator(counts[partition]);
      HashMap<CategoryListIterator, Aggregator> map = new HashMap<CategoryListIterator, Aggregator>();
      for (CategoryListParams clp: facetIndexingParams.getAllCategoryListParams()) {
        map.put(clp.createCategoryListIterator(partition), aggregator);
      }
      return map;
    }
  };
  sfa.setComplementThreshold(StandardFacetsAccumulator.DISABLE_COMPLEMENT);
  sfa.accumulate(ScoredDocIdsUtils.createAllDocsScoredDocIDs(indexReader));
  return new TotalFacetCounts(taxonomy, facetIndexingParams, counts, CreationType.Computed);
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
static TotalFacetCounts compute(final IndexReader indexReader, final TaxonomyReader taxonomy, 
    final FacetIndexingParams facetIndexingParams) throws IOException {
  int partitionSize = PartitionsUtils.partitionSize(facetIndexingParams, taxonomy);
  final int[][] counts = new int[(int) Math.ceil(taxonomy.getSize()  /(float) partitionSize)][partitionSize];
  FacetSearchParams newSearchParams = new FacetSearchParams(facetIndexingParams, DUMMY_REQ); 
    //createAllListsSearchParams(facetIndexingParams,  this.totalCounts);
  OldFacetsAccumulator sfa = new OldFacetsAccumulator(newSearchParams, indexReader, taxonomy) {
    @Override
    protected HashMap<CategoryListIterator, Aggregator> getCategoryListMap(
        FacetArrays facetArrays, int partition) throws IOException {
      
      Aggregator aggregator = new CountingAggregator(counts[partition]);
      HashMap<CategoryListIterator, Aggregator> map = new HashMap<CategoryListIterator, Aggregator>();
      for (CategoryListParams clp: facetIndexingParams.getAllCategoryListParams()) {
        map.put(clp.createCategoryListIterator(partition), aggregator);
      }
      return map;
    }
  };
  sfa.setComplementThreshold(OldFacetsAccumulator.DISABLE_COMPLEMENT);
  sfa.accumulate(ScoredDocIdsUtils.createAllDocsScoredDocIDs(indexReader));
  return new TotalFacetCounts(taxonomy, facetIndexingParams, counts, CreationType.Computed);
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
/** Init arrays for partition by total counts, optionally applying a factor */
private final void initArraysByTotalCounts(FacetArrays facetArrays, int partition, int nAccumulatedDocs) {
  int[] intArray = facetArrays.getIntArray();
  totalFacetCounts.fillTotalCountsForPartition(intArray, partition);
  double totalCountsFactor = getTotalCountsFactor();
  // fix total counts, but only if the effect of this would be meaningful. 
  if (totalCountsFactor < 0.99999) {
    int delta = nAccumulatedDocs + 1;
    for (int i = 0; i < intArray.length; i++) {
      intArray[i] *= totalCountsFactor;
      // also translate to prevent loss of non-positive values
      // due to complement sampling (ie if sampled docs all decremented a certain category). 
      intArray[i] += delta; 
    }
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
protected Aggregator createAggregator(FacetRequest fr, FacetArrays facetArrays) {
  if (fr instanceof CountFacetRequest) {
    // we rely on that, if needed, result is cleared by arrays!
    int[] a = facetArrays.getIntArray();
    if (isUsingComplements) {
      return new ComplementCountingAggregator(a);
    } else {
      return new CountingAggregator(a);
    }
  } else if (fr instanceof SumScoreFacetRequest) {
    if (isUsingComplements) {
      throw new IllegalArgumentException("complements are not supported by SumScoreFacetRequest");
    } else {
      return new ScoringAggregator(facetArrays.getFloatArray());
    }
  } else if (fr instanceof OverSampledFacetRequest) {
    return createAggregator(((OverSampledFacetRequest) fr).orig, facetArrays);
  } else {
    throw new IllegalArgumentException("unknown Aggregator implementation for request " + fr.getClass());
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
/**
 * Create an {@link Aggregator} and a {@link CategoryListIterator} for each
 * and every {@link FacetRequest}. Generating a map, matching each
 * categoryListIterator to its matching aggregator.
 * <p>
 * If two CategoryListIterators are served by the same aggregator, a single
 * aggregator is returned for both.
 * 
 * <b>NOTE: </b>If a given category list iterator is needed with two different
 * aggregators (e.g counting and association) - an exception is thrown as this
 * functionality is not supported at this time.
 */
protected HashMap<CategoryListIterator, Aggregator> getCategoryListMap(FacetArrays facetArrays,
    int partition) throws IOException {
  
  HashMap<CategoryListIterator, Aggregator> categoryLists = new HashMap<CategoryListIterator, Aggregator>();

  FacetIndexingParams indexingParams = searchParams.indexingParams;
  for (FacetRequest facetRequest : searchParams.facetRequests) {
    Aggregator categoryAggregator = createAggregator(facetRequest, facetArrays);

    CategoryListIterator cli = indexingParams.getCategoryListParams(facetRequest.categoryPath).createCategoryListIterator(partition);
    
    // get the aggregator
    Aggregator old = categoryLists.put(cli, categoryAggregator);

    if (old != null && !old.equals(categoryAggregator)) {
      throw new RuntimeException("Overriding existing category list with different aggregator");
    }
    // if the aggregator is the same we're covered
  }

  return categoryLists;
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void aggregate(MatchingDocs matchingDocs, CategoryListParams clp, FacetArrays facetArrays) throws IOException {
  BinaryDocValues dv = matchingDocs.context.reader().getBinaryDocValues(clp.field + CategoryIntAssociation.ASSOCIATION_LIST_ID);
  if (dv == null) {
    return; // no int associations in this reader
  }
  
  final int length = matchingDocs.bits.length();
  final int[] values = facetArrays.getIntArray();
  int doc = 0;
  while (doc < length && (doc = matchingDocs.bits.nextSetBit(doc)) != -1) {
    dv.get(doc, bytes);
    if (bytes.length == 0) {
      continue; // no associations for this document
    }

    // aggreate association values for ordinals
    int bytesUpto = bytes.offset + bytes.length;
    int pos = bytes.offset;
    while (pos < bytesUpto) {
      int ordinal = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
          | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
      
      int value = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
          | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);

      values[ordinal] += value;
    }
    
    ++doc;
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void aggregate(MatchingDocs matchingDocs, CategoryListParams clp, FacetArrays facetArrays) throws IOException {
  BinaryDocValues dv = matchingDocs.context.reader().getBinaryDocValues(clp.field + CategoryFloatAssociation.ASSOCIATION_LIST_ID);
  if (dv == null) {
    return; // no float associations in this reader
  }
  
  final int length = matchingDocs.bits.length();
  final float[] values = facetArrays.getFloatArray();
  int doc = 0;
  while (doc < length && (doc = matchingDocs.bits.nextSetBit(doc)) != -1) {
    dv.get(doc, bytes);
    if (bytes.length == 0) {
      continue; // no associations for this document
    }

    // aggreate float association values for ordinals
    int bytesUpto = bytes.offset + bytes.length;
    int pos = bytes.offset;
    while (pos < bytesUpto) {
      int ordinal = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
          | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
      
      int value = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
          | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);

      values[ordinal] += Float.intBitsToFloat(value);
    }
    
    ++doc;
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
public SortedSetDocValuesAccumulator(SortedSetDocValuesReaderState state, FacetSearchParams fsp, FacetArrays arrays) 
    throws IOException {
  super(fsp);
  this.state = state;
  this.field = state.getField();
  this.facetArrays = arrays == null ? new FacetArrays(state.getSize()) : arrays;
  dv = state.getDocValues();

  // Check params:
  for (FacetRequest fr : fsp.facetRequests) {
    if (!(fr instanceof CountFacetRequest)) {
      throw new IllegalArgumentException("this accumulator only supports CountFacetRequest; got " + fr);
    }
    if (fr.categoryPath.length != 1) {
      throw new IllegalArgumentException("this accumulator only supports 1-level CategoryPath; got " + fr.categoryPath);
    }
    if (fr.getDepth() != 1) {
      throw new IllegalArgumentException("this accumulator only supports depth=1; got " + fr.getDepth());
    }
    String dim = fr.categoryPath.components[0];

    SortedSetDocValuesReaderState.OrdRange ordRange = state.getOrdRange(dim);
    if (ordRange == null) {
      throw new IllegalArgumentException("dim \"" + dim + "\" does not exist");
    }
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void aggregate(MatchingDocs matchingDocs, CategoryListParams clp, FacetArrays facetArrays) throws IOException {
  BinaryDocValues dv = matchingDocs.context.reader().getBinaryDocValues(clp.field + CategoryIntAssociation.ASSOCIATION_LIST_ID);
  if (dv == null) {
    return; // no int associations in this reader
  }
  
  final int length = matchingDocs.bits.length();
  final int[] values = facetArrays.getIntArray();
  int doc = 0;
  while (doc < length && (doc = matchingDocs.bits.nextSetBit(doc)) != -1) {
    dv.get(doc, bytes);
    if (bytes.length > 0) {
      // aggreate association values for ordinals
      int bytesUpto = bytes.offset + bytes.length;
      int pos = bytes.offset;
      while (pos < bytesUpto) {
        int ordinal = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
            | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
        
        int value = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
            | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
        
        values[ordinal] += value;
      }
    }
    ++doc;
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void aggregate(MatchingDocs matchingDocs, CategoryListParams clp, FacetArrays facetArrays) throws IOException {
  BinaryDocValues dv = matchingDocs.context.reader().getBinaryDocValues(clp.field + CategoryFloatAssociation.ASSOCIATION_LIST_ID);
  if (dv == null) {
    return; // no float associations in this reader
  }
  
  final int length = matchingDocs.bits.length();
  final float[] values = facetArrays.getFloatArray();
  int doc = 0;
  while (doc < length && (doc = matchingDocs.bits.nextSetBit(doc)) != -1) {
    dv.get(doc, bytes);
    if (bytes.length > 0) {
      // aggreate float association values for ordinals
      int bytesUpto = bytes.offset + bytes.length;
      int pos = bytes.offset;
      while (pos < bytesUpto) {
        int ordinal = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
            | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
        
        int value = ((bytes.bytes[pos++] & 0xFF) << 24) | ((bytes.bytes[pos++] & 0xFF) << 16)
            | ((bytes.bytes[pos++] & 0xFF) <<  8) | (bytes.bytes[pos++] & 0xFF);
        
        values[ordinal] += Float.intBitsToFloat(value);
      }
    }
    ++doc;
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
public OldFacetsAccumulator(FacetSearchParams searchParams, IndexReader indexReader,
    TaxonomyReader taxonomyReader, FacetArrays facetArrays) {
  super(searchParams, indexReader, taxonomyReader, facetArrays == null ? createFacetArrays(searchParams, taxonomyReader) : facetArrays);
  
  // can only be computed later when docids size is known
  isUsingComplements = false;
  partitionSize = PartitionsUtils.partitionSize(searchParams.indexingParams, taxonomyReader);
  maxPartitions = (int) Math.ceil(this.taxonomyReader.getSize() / (double) partitionSize);
  accumulateGuard = new Object();
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
public PartitionsFacetResultsHandler(TaxonomyReader taxonomyReader, FacetRequest facetRequest, 
    FacetArrays facetArrays) {
  super(taxonomyReader, facetRequest, facetArrays);
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void rollupValues(FacetRequest fr, int ordinal, int[] children, int[] siblings, FacetArrays facetArrays) {
  float[] values = facetArrays.getFloatArray();
  values[ordinal] += rollupValues(children[ordinal], children, siblings, values);
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void aggregate(MatchingDocs matchingDocs, CategoryListParams clp, FacetArrays facetArrays) throws IOException {
  for (FacetsAggregator fa : aggregators) {
    fa.aggregate(matchingDocs, clp, facetArrays);
  }
}
 

import org.apache.lucene.facet.search.FacetArrays; //导入依赖的package包/类
@Override
public void rollupValues(FacetRequest fr, int ordinal, int[] children, int[] siblings, FacetArrays facetArrays) {
  categoryAggregators.get(fr.categoryPath).rollupValues(fr, ordinal, children, siblings, facetArrays);
}