static FacetDataCache MakeFacetDataCache()
{
FacetDataCache cache = new FacetDataCache();
cache.Freqs = new int[numVals];
Random r = new Random();
for (int i = 0; i < cache.Freqs.Length; ++i)
{
int p = r.Next(100);
int v;
if (p % 100 < percent_zero)
{
v = 0;
}
else
{
v = Math.Abs(rand.Next(numDocs - 1)) + 1;
}
cache.Freqs[i] = v;
}
//Arrays.Fill(cache.Freqs, 1);
cache.MaxIDs = new int[numVals];
cache.MinIDs = new int[numVals];
cache.ValArray = new TermIntList(numVals, "0000000000");
for (int i = 0; i < numVals; ++i)
{
cache.ValArray.Add((i + 1).ToString("0000000000"));
}
cache.ValArray.Seal();
cache.OrderArray = new BigIntArray(numDocsPerSeg);
return cache;
}
public FacetDocIdSetIterator(FacetDataCache dataCache, int index)
{
_index = index;
_doc = Math.Max(-1, dataCache.MinIDs[_index] - 1);
_maxID = dataCache.MaxIDs[_index];
_orderArray = dataCache.OrderArray;
}
public FacetDocIdSetIterator(FacetDataCache dataCache, int index)
{
this.index = index;
doc = Math.Max(-1, dataCache.minIDs[this.index] - 1);
maxID = dataCache.maxIDs[this.index];
orderArray = dataCache.orderArray;
}
public BitSetRandomAccessDocIdSet(bool multi, MultiValueFacetDataCache multiCache, OpenBitSet openBitSet, FacetDataCache dataCache)
{
_multi = multi;
_multiCache = multiCache;
_openBitSet = openBitSet;
_dataCache = dataCache;
}
public RangeFacetCountCollector(string name, FacetDataCache dataCache, int docBase, FacetSpec ospec, IEnumerable<string> predefinedRanges)
{
_name = name;
_dataCache = dataCache;
_countLength = _dataCache.Freqs.Length;
_count = new LazyBigIntArray(_countLength);
_array = _dataCache.OrderArray;
_docBase = docBase;
_ospec = ospec;
if (predefinedRanges != null)
{
_predefinedRanges = new TermStringList();
var tempList = new List<string>(predefinedRanges);
tempList.Sort();
_predefinedRanges.AddAll(tempList);
}
else
{
_predefinedRanges = null;
}
if (_predefinedRanges != null)
{
_predefinedRangeIndexes = new int[_predefinedRanges.Count()][];
int i = 0;
foreach (string range in this._predefinedRanges)
{
_predefinedRangeIndexes[i++] = FacetRangeFilter.Parse(this._dataCache, range);
}
}
}
/// <summary>
/// Same as ConvertString(FacetDataCache dataCache,string[] vals) except that the
/// values are supplied in raw form so that we can take advantage of the type
/// information to find index faster.
/// </summary>
/// <param name="dataCache"></param>
/// <param name="vals"></param>
/// <returns>the array of order indices of the values.</returns>
public static int[] Convert <T>(FacetDataCache dataCache, T[] vals)
{
if (vals != null && (typeof(T) == typeof(string)))
{
var valsString = vals.Cast <string>().ToArray();
return(ConvertString(dataCache, valsString));
}
var list = new List <int>(vals.Length);
for (int i = 0; i < vals.Length; ++i)
{
int index = -1;
var valArrayTyped = dataCache.ValArray as TermValueList <T>;
if (valArrayTyped != null)
{
index = valArrayTyped.IndexOfWithType(vals[i]);
}
else
{
index = dataCache.ValArray.IndexOf(vals[i]);
}
if (index >= 0)
{
list.Add(index);
}
}
return(list.ToArray());
}
public PathFacetHandler(string name)
: base(name)
{
dataCache = null;
termListFactory = TermListFactory.StringListFactory;
separator = DEFAULT_SEP;
}
public SimpleFacetHandler(string name, string indexFieldName, TermListFactory termListFactory)
: base(name)
{
_indexFieldName = indexFieldName;
_dataCache = null;
_termListFactory = termListFactory;
}
//private int _totalGroups; // NOT USED
public GroupByFacetCountCollector(string name,
FacetDataCache dataCache,
int docBase,
BrowseSelection sel,
FacetSpec ospec)
: base(name, dataCache, docBase, sel, ospec)
{
}
public DefaultFacetCountCollector(BrowseSelection sel, FacetDataCache dataCache, string name, FacetSpec ospec)
{
_sel = sel;
_ospec = ospec;
_name = name;
_dataCache = dataCache;
_count = new int[_dataCache.freqs.Length];
_array = _dataCache.orderArray;
}
public RangeFacetHandler(string name, string indexFieldName, TermListFactory termListFactory, bool autoRange)
: base(name)
{
this.dataCache = null;
this.indexFieldName = indexFieldName;
this.termListFactory = termListFactory;
this.predefinedRanges = null;
this.autoRange = autoRange;
}
public RangeFacetHandler(string name, string indexFieldName, TermListFactory termListFactory, IEnumerable<string> predefinedRanges)
: base(name)
{
this.indexFieldName = indexFieldName;
this.dataCache = null;
this.termListFactory = termListFactory;
this.predefinedRanges = predefinedRanges;
this.autoRange = false;
}
public virtual OpenBitSet GetBitSet(FacetDataCache dataCache)
{
if (lastCache == dataCache)
{
return bitSet;
}
bitSet = bitSetBuilder.BitSet(dataCache);
lastCache = dataCache;
return bitSet;
}
public CompactMultiValueFacetFilter(FacetDataCache dataCache, int[] index)
{
this.dataCache = dataCache;
orderArray = this.dataCache.orderArray;
this.index = index;
bits = 0x0;
foreach (int i in index)
{
bits |= 0x00000001 << (i - 1);
}
}
public override DocComparator GetComparator(IndexReader reader, int docbase)
{
if (!(reader.GetType().Equals(typeof(BoboIndexReader))))
{
throw new ArgumentException("reader not instance of BoboIndexReader");
}
BoboIndexReader boboReader = (BoboIndexReader)reader;
FacetDataCache dataCache = _facetHandler.GetFacetData <FacetDataCache>(boboReader);
BigSegmentedArray orderArray = dataCache.OrderArray;
return(new FacetDocComparator(dataCache, orderArray));
}
public override DocComparer GetComparer(AtomicReader reader, int docbase)
{
if (!(reader is BoboSegmentReader))
{
throw new ArgumentException("reader not instance of BoboSegmentReader");
}
BoboSegmentReader boboReader = (BoboSegmentReader)reader;
FacetDataCache dataCache = m_facetHandler.GetFacetData <FacetDataCache>(boboReader);
BigSegmentedArray orderArray = dataCache.OrderArray;
return(new FacetDocComparer(dataCache, orderArray));
}
internal FacetRangeDocIdSetIterator(int start, int end, FacetDataCache dataCache)
{
_start = start;
_end = end;
for (int i = start; i <= end; ++i)
{
_minID = Math.Min(_minID, dataCache.MinIDs[i]);
_maxID = Math.Max(_maxID, dataCache.MaxIDs[i]);
}
_doc = Math.Max(-1, _minID - 1);
_orderArray = dataCache.OrderArray;
}
private static int[] ConvertString(FacetDataCache dataCache, string[] vals)
{
var list = new List <int>(vals.Length);
for (int i = 0; i < vals.Length; ++i)
{
int index = dataCache.ValArray.IndexOf(vals[i]);
if (index >= 0)
{
list.Add(index);
}
}
return(list.ToArray());
}
public FacetOrFilter(FacetDataCache dataCache, int[] index, bool takeCompliment)
{
this.dataCache = dataCache;
orderArray = dataCache.orderArray;
this.index = index;
bitset = new OpenBitSet(this.dataCache.valArray.Count);
foreach (int i in this.index)
{
bitset.FastSet(i);
}
if (takeCompliment)
{
bitset.Flip(0, this.dataCache.valArray.Count);
}
}
public virtual OpenBitSet BitSet(FacetDataCache dataCache)
{
int[] index = facetValueConverter.Convert(dataCache, vals);
OpenBitSet bitset = new OpenBitSet(dataCache.ValArray.Count);
foreach (int i in index)
{
bitset.FastSet(i);
}
if (takeCompliment)
{
// flip the bits
for (int i = 0; i < index.Length; ++i)
{
bitset.FastFlip(i);
}
}
return bitset;
}
protected internal RangeFacetCountCollector(string name, FacetDataCache dataCache, FacetSpec ospec, IEnumerable<string> predefinedRanges, bool autoRange)
{
this.name = name;
this.dataCache = dataCache;
this.ospec = ospec;
count = new int[this.dataCache.freqs.Length];
orderArray = this.dataCache.orderArray;
this.predefinedRanges = predefinedRanges;
this.autoRange = autoRange;
if (this.predefinedRanges != null)
{
predefinedRangeIndexes = new int[this.predefinedRanges.Count()][];
int i = 0;
foreach (string range in this.predefinedRanges)
{
predefinedRangeIndexes[i++] = RangeFacetHandler.Parse(this.dataCache, range);
}
}
}
public GeoSimpleFacetCountCollector(string name, FacetDataCache latDataCache, FacetDataCache longDataCache, int docBase, FacetSpec spec, IEnumerable<string> predefinedRanges)
{
_name = name;
_latDataCache = latDataCache;
_longDataCache = longDataCache;
_latCount = new int[_latDataCache.Freqs.Length];
_longCount = new int[_longDataCache.Freqs.Length];
log.Info("latCount: " + _latDataCache.Freqs.Length + " longCount: " + _longDataCache.Freqs.Length);
_latOrderArray = _latDataCache.OrderArray;
_longOrderArray = _longDataCache.OrderArray;
_docBase = docBase;
_spec = spec;
_predefinedRanges = new TermStringList();
var predefinedRangesTemp = new List<string>(predefinedRanges);
predefinedRangesTemp.Sort();
_predefinedRanges.AddAll(predefinedRangesTemp);
if (predefinedRanges != null)
{
_latPredefinedRangeIndexes = new int[_predefinedRanges.Count][];
for (int j = 0; j < _latPredefinedRangeIndexes.Length; j++)
{
_latPredefinedRangeIndexes[j] = new int[2];
}
_longPredefinedRangeIndexes = new int[_predefinedRanges.Count][];
for (int j = 0; j < _longPredefinedRangeIndexes.Length; j++)
{
_longPredefinedRangeIndexes[j] = new int[2];
}
int i = 0;
foreach (string range in _predefinedRanges)
{
int[] ranges = GeoSimpleFacetFilter.Parse(_latDataCache, _longDataCache, range);
_latPredefinedRangeIndexes[i][0] = ranges[0]; // latStart
_latPredefinedRangeIndexes[i][1] = ranges[1]; // latEnd
_longPredefinedRangeIndexes[i][0] = ranges[2]; // longStart
_longPredefinedRangeIndexes[i][1] = ranges[3]; // longEnd
i++;
}
}
}
internal GeoSimpleDocIdSetIterator(int latStart, int latEnd, int longStart, int longEnd, FacetDataCache latDataCache, FacetDataCache longDataCache)
{
//_totalFreq = 0; // NOT USED
_latStart = latStart;
_longStart = longStart;
_latEnd = latEnd;
_longEnd = longEnd;
for (int i = latStart; i <= latEnd; ++i)
{
_minID = Math.Min(_minID, latDataCache.MinIDs[i]);
_maxID = Math.Max(_maxID, latDataCache.MaxIDs[i]);
}
for (int i = longStart; i <= longEnd; ++i)
{
_minID = Math.Min(_minID, longDataCache.MinIDs[i]);
_maxID = Math.Max(_maxID, longDataCache.MaxIDs[i]);
}
_doc = Math.Max(-1, _minID - 1);
_latOrderArray = latDataCache.OrderArray;
_longOrderArray = longDataCache.OrderArray;
}
public CompactMultiValueFacetDocIdSetIterator(FacetDataCache dataCache, int[] index, int bits)
{
this.bits = bits;
doc = int.MaxValue;
maxID = -1;
orderArray = dataCache.orderArray;
foreach (int i in index)
{
if (doc > dataCache.minIDs[i])
{
doc = dataCache.minIDs[i];
}
if (maxID < dataCache.maxIDs[i])
{
maxID = dataCache.maxIDs[i];
}
}
doc--;
if (doc < 0)
{
doc = -1;
}
}
public CompactMultiValueFacetDocIdSetIterator(FacetDataCache dataCache, int[] index, int bits)
{
_bits = bits;
_doc = int.MaxValue;
_maxID = -1;
_orderArray = dataCache.OrderArray;
foreach (int i in index)
{
if (_doc > dataCache.MinIDs[i])
{
_doc = dataCache.MinIDs[i];
}
if (_maxID < dataCache.MaxIDs[i])
{
_maxID = dataCache.MaxIDs[i];
}
}
_doc--;
if (_doc < 0)
{
_doc = -1;
}
}
public DefaultFacetCountCollector(string name, FacetDataCache dataCache, int docBase, BrowseSelection sel, FacetSpec ospec)
{
_sel = sel;
_ospec = ospec;
_name = name;
_dataCache = dataCache;
_countlength = _dataCache.Freqs.Length;
if (_dataCache.Freqs.Length <= 3096)
{
_count = new LazyBigIntArray(_countlength);
}
else
{
_count = new LazyBigIntArray(_countlength);
// NOTE: Removed memory manager implementation
//_count = intarraymgr.Get(_countlength);
//intarraylist.Add(_count);
}
_array = _dataCache.OrderArray;
_docBase = docBase;
}
public SimpleBoboDocScorer(FacetDataCache dataCache, IFacetTermScoringFunctionFactory scoreFunctionFactory, float[] boostList)
: base(scoreFunctionFactory.GetFacetTermScoringFunction(dataCache.valArray.Count, dataCache.orderArray.Size()), boostList)
{
_dataCache = dataCache;
}
public SimpleFacetCountCollector(BrowseSelection sel, FacetDataCache dataCache, string name, FacetSpec ospec)
: base(sel, dataCache, name, ospec)
{
}
public override void Load(BoboIndexReader reader)
{
if (_dataCache == null)
{
_dataCache = new FacetDataCache();
}
_dataCache.Load(_indexFieldName, reader, _termListFactory);
}
public int[] Convert(FacetDataCache dataCache, string[] vals){
return FacetDataCache.Convert(dataCache, vals);
}
public CompactMultiValueFacetFilterDocIdSet(FacetDataCache dataCache, int[] indexes, int finalBits, BigSegmentedArray orderArray)
{
this.dataCache = dataCache;
this.indexes = indexes;
this.finalBits = finalBits;
this.orderArray = orderArray;
}
public FacetFieldComparator(int numHits,int type, FacetDataCache dataCache)
{
_docs = new int[numHits];
_fieldType = type;
_dataCache = dataCache;
orderArray = _dataCache.orderArray;
}
public static int[] Convert(FacetDataCache dataCache, string[] vals)
{
List<int> list = new List<int>(vals.Length);
for (int i = 0; i < vals.Length; ++i)
{
int index = dataCache.valArray.IndexOf(vals[i]);
if (index >= 0)
{
list.Add(index);
}
}
return list.ToArray();
}
public FacetOrFilter(FacetDataCache dataCache, int[] index)
: this(dataCache, index, false)
{
}
public FacetDocComparator(FacetDataCache dataCache, BigSegmentedArray orderArray)
{
_dataCache = dataCache;
_orderArray = orderArray;
}
public FacetDocComparer(FacetDataCache dataCache, BigSegmentedArray orderArray)
{
m_dataCache = dataCache;
m_orderArray = orderArray;
}
