internal PathFacetCountCollector(string name, string sep, BrowseSelection sel, FacetSpec ospec, FacetDataCache dataCache)
{
_sel = sel;
_ospec = ospec;
_name = name;
_dataCache = dataCache;
_sep = sep;
_sepArray = sep.ToCharArray();
_count = new LazyBigIntArray(_dataCache.Freqs.Length);
log.Info(name + ": " + _count.Size());
_orderArray = _dataCache.OrderArray;
_minHitCount = ospec.MinHitCount;
_maxCount = ospec.MaxCount;
if (_maxCount < 1)
{
_maxCount = _count.Size();
}
FacetSpec.FacetSortSpec sortOption = ospec.OrderBy;
switch (sortOption)
{
case FacetSpec.FacetSortSpec.OrderHitsDesc: _comparatorFactory = new FacetHitcountComparatorFactory(); break;
case FacetSpec.FacetSortSpec.OrderValueAsc: _comparatorFactory = null; break;
case FacetSpec.FacetSortSpec.OrderByCustom: _comparatorFactory = ospec.CustomComparatorFactory; break;
default: throw new ArgumentOutOfRangeException("invalid sort option: " + sortOption);
}
_splitPat = new Regex(_sep, RegexOptions.Compiled);
_stringData = new string[10];
_patStart = 0;
_patEnd = 0;
}
private FacetSpec.FacetSortSpec ParseFacetSort(string facetSortString, FacetSpec.FacetSortSpec defaultSort)
{
FacetSpec.FacetSortSpec defaultFacetSortSpec;
if ("count".Equals(facetSortString))
{
defaultFacetSortSpec = FacetSpec.FacetSortSpec.OrderHitsDesc;
}
else if ("index".Equals(facetSortString))
{
defaultFacetSortSpec = FacetSpec.FacetSortSpec.OrderValueAsc;
}
else
{
defaultFacetSortSpec = defaultSort;
}
return(defaultFacetSortSpec);
}
public virtual ICollection <BrowseFacet> GetFacets()
{
if (m_ospec != null)
{
int minCount = m_ospec.MinHitCount;
int max = m_ospec.MaxCount;
if (max <= 0)
{
max = m_count.Length;
}
List <BrowseFacet> facetColl;
FacetSpec.FacetSortSpec sortspec = m_ospec.OrderBy;
if (sortspec == FacetSpec.FacetSortSpec.OrderValueAsc)
{
facetColl = new List <BrowseFacet>(max);
for (int i = 0; i < m_count.Length; ++i)
{
int hits = m_count.Get(i);
if (hits >= minCount)
{
BrowseFacet facet = new BrowseFacet(i.ToString(NUMBER_FORMAT), hits);
facetColl.Add(facet);
}
if (facetColl.Count >= max)
{
break;
}
}
return(facetColl);
}
else
{
return(FacetCountCollector.EMPTY_FACET_LIST);
}
}
else
{
return(FacetCountCollector.EMPTY_FACET_LIST);
}
}
internal PathFacetCountCollector(string name, string sep, BrowseSelection sel, FacetSpec ospec, FacetDataCache dataCache)
{
m_sel = sel;
m_name = name;
m_dataCache = dataCache;
m_sep = sep;
m_sepArray = sep.ToCharArray();
m_count = new LazyBigInt32Array(m_dataCache.Freqs.Length);
log.Info(name + ": " + m_count.Length);
m_orderArray = m_dataCache.OrderArray;
m_minHitCount = ospec.MinHitCount;
m_maxCount = ospec.MaxCount;
if (m_maxCount < 1)
{
m_maxCount = m_count.Length;
}
FacetSpec.FacetSortSpec sortOption = ospec.OrderBy;
switch (sortOption)
{
case FacetSpec.FacetSortSpec.OrderHitsDesc:
m_comparerFactory = new FacetHitcountComparerFactory();
break;
case FacetSpec.FacetSortSpec.OrderValueAsc:
m_comparerFactory = null;
break;
case FacetSpec.FacetSortSpec.OrderByCustom:
m_comparerFactory = ospec.CustomComparerFactory;
break;
default:
throw new ArgumentOutOfRangeException("invalid sort option: " + sortOption);
}
// Doesn't make much sense to do this, so it is commented.
// new Regex(_sep, RegexOptions.Compiled);
m_stringData = new string[10];
m_patStart = 0;
m_patEnd = 0;
}
public static IEnumerable <BrowseFacet> GetFacets(FacetSpec ospec, BigSegmentedArray count, int countlength, ITermValueList valList)
{
if (ospec != null)
{
int minCount = ospec.MinHitCount;
int max = ospec.MaxCount;
if (max <= 0)
{
max = countlength;
}
LinkedList <BrowseFacet> facetColl;
FacetSpec.FacetSortSpec sortspec = ospec.OrderBy;
if (sortspec == FacetSpec.FacetSortSpec.OrderValueAsc)
{
facetColl = new LinkedList <BrowseFacet>();
for (int i = 1; i < countlength; ++i) // exclude zero
{
int hits = count.Get(i);
if (hits >= minCount)
{
BrowseFacet facet = new BrowseFacet(valList.Get(i), hits);
facetColl.AddLast(facet);
}
if (facetColl.Count >= max)
{
break;
}
}
}
else //if (sortspec == FacetSortSpec.OrderHitsDesc)
{
IComparatorFactory comparatorFactory;
if (sortspec == FacetSpec.FacetSortSpec.OrderHitsDesc)
{
comparatorFactory = new FacetHitcountComparatorFactory();
}
else
{
comparatorFactory = ospec.CustomComparatorFactory;
}
if (comparatorFactory == null)
{
throw new ArgumentException("facet comparator factory not specified");
}
IComparer <int> comparator = comparatorFactory.NewComparator(new DefaultFacetCountCollectorFieldAccessor(valList), count);
facetColl = new LinkedList <BrowseFacet>();
int forbidden = -1;
IntBoundedPriorityQueue pq = new IntBoundedPriorityQueue(comparator, max, forbidden);
for (int i = 1; i < countlength; ++i) // exclude zero
{
int hits = count.Get(i);
if (hits >= minCount)
{
pq.Offer(i);
}
}
int val;
while ((val = pq.Poll()) != forbidden)
{
BrowseFacet facet = new BrowseFacet(valList[val], count.Get(val));
facetColl.AddFirst(facet);
}
}
return(facetColl);
}
else
{
return(FacetCountCollector_Fields.EMPTY_FACET_LIST);
}
}
public IntRangeFacetField(string alias, string label, FacetSpec.FacetSortSpec valueOrderBy = FacetSpec.FacetSortSpec.OrderValueAsc, bool expandSelection = true, int minHitCount = 0, BrowseSelection.ValueOperation valueOperation = BrowseSelection.ValueOperation.ValueOperationOr) : base(alias, label, false, valueOrderBy, expandSelection, minHitCount, valueOperation)
{
}
public static IDictionary <string, IFacetAccessible> MergeSimpleFacetContainers(IEnumerable <IDictionary <string, IFacetAccessible> > subMaps, BrowseRequest req)
{
Dictionary <string, Dictionary <object, BrowseFacet> > counts = new Dictionary <string, Dictionary <object, BrowseFacet> >();
foreach (Dictionary <string, IFacetAccessible> subMap in subMaps)
{
foreach (KeyValuePair <string, IFacetAccessible> entry in subMap)
{
Dictionary <object, BrowseFacet> count = counts[entry.Key];
if (count == null)
{
count = new Dictionary <object, BrowseFacet>();
counts.Add(entry.Key, count);
}
foreach (BrowseFacet facet in entry.Value.GetFacets())
{
string val = facet.Value;
BrowseFacet oldValue = count[val];
if (oldValue == null)
{
count.Add(val, new BrowseFacet(val, facet.FacetValueHitCount));
}
else
{
oldValue.FacetValueHitCount = oldValue.FacetValueHitCount + facet.FacetValueHitCount;
}
}
}
}
Dictionary <string, IFacetAccessible> mergedFacetMap = new Dictionary <string, IFacetAccessible>();
foreach (string facet in counts.Keys)
{
FacetSpec fs = req.GetFacetSpec(facet);
FacetSpec.FacetSortSpec sortSpec = fs.OrderBy;
IComparer <BrowseFacet> comparator;
if (FacetSpec.FacetSortSpec.OrderValueAsc.Equals(sortSpec))
{
comparator = FACET_VAL_COMPARATOR;
}
else if (FacetSpec.FacetSortSpec.OrderHitsDesc.Equals(sortSpec))
{
comparator = FacetHitcountComparatorFactory.FACET_HITS_COMPARATOR;
}
else
{
comparator = fs.CustomComparatorFactory.NewComparator();
}
Dictionary <object, BrowseFacet> facetValueCounts = counts[facet];
BrowseFacet[] facetArray = facetValueCounts.Values.ToArray();
Array.Sort(facetArray, comparator);
int numToShow = facetArray.Length;
if (req != null)
{
FacetSpec fspec = req.GetFacetSpec(facet);
if (fspec != null)
{
int maxCount = fspec.MaxCount;
if (maxCount > 0)
{
numToShow = Math.Min(maxCount, numToShow);
}
}
}
BrowseFacet[] facets;
if (numToShow == facetArray.Length)
{
facets = facetArray;
}
else
{
facets = new BrowseFacet[numToShow];
Array.Copy(facetArray, 0, facets, 0, numToShow);
}
MappedFacetAccessible mergedFacetAccessible = new MappedFacetAccessible(facets);
mergedFacetMap.Add(facet, mergedFacetAccessible);
}
return(mergedFacetMap);
}
public virtual ICollection <BrowseFacet> GetFacets()
{
if (m_fspec != null)
{
int minCount = m_fspec.MinHitCount;
int max = m_fspec.MaxCount;
if (max <= 0)
{
max = m_countlength;
}
FacetSpec.FacetSortSpec sortspec = m_fspec.OrderBy;
List <BrowseFacet> facetColl;
if (sortspec == FacetSpec.FacetSortSpec.OrderValueAsc)
{
facetColl = new List <BrowseFacet>(max);
for (int i = 1; i < m_countlength; ++i) // exclude zero
{
int hits = m_count.Get(i);
if (hits >= minCount)
{
BrowseFacet facet = new BrowseFacet(GetFacetString(i), hits);
facetColl.Add(facet);
}
if (facetColl.Count >= max)
{
break;
}
}
}
else
{
IComparerFactory comparerFactory;
if (sortspec == FacetSpec.FacetSortSpec.OrderHitsDesc)
{
comparerFactory = new FacetHitcountComparerFactory();
}
else
{
comparerFactory = m_fspec.CustomComparerFactory;
}
if (comparerFactory == null)
{
throw new System.ArgumentException("facet comparer factory not specified");
}
IComparer <int> comparer = comparerFactory.NewComparer(new GroupbyFieldValueAccessor(this.GetFacetString, this.GetRawFaceValue), m_count);
facetColl = new List <BrowseFacet>();
int forbidden = -1;
Int32BoundedPriorityQueue pq = new Int32BoundedPriorityQueue(comparer, max, forbidden);
for (int i = 1; i < m_countlength; ++i) // exclude zero
{
int hits = m_count.Get(i);
if (hits >= minCount)
{
if (!pq.Offer(i))
{
// pq is full. we can safely ignore any facet with <=hits.
minCount = hits + 1;
}
}
}
int val;
while ((val = pq.Poll()) != forbidden)
{
BrowseFacet facet = new BrowseFacet(GetFacetString(val), m_count.Get(val));
facetColl.Insert(0, facet);
}
}
return(facetColl);
}
else
{
return(FacetCountCollector.EMPTY_FACET_LIST);
}
}
public void ApplyFacetSpec(string name, int minHitCount, int maxCount, bool expand, FacetSpec.FacetSortSpec orderBy)
{
FacetSpec fspec = new FacetSpec();
fspec.MinHitCount = minHitCount;
fspec.MaxCount = maxCount;
fspec.ExpandSelection = expand;
fspec.OrderBy = orderBy;
m_req.SetFacetSpec(name, fspec);
}
public virtual List <BrowseFacet> GetFacetsNew()
{
if (_ospec != null)
{
if (_predefinedRangeIndexes != null)
{
int minCount = _ospec.MinHitCount;
int maxNumOfFacets = _ospec.MaxCount;
if (maxNumOfFacets <= 0 || maxNumOfFacets > _predefinedRangeIndexes.Length)
{
maxNumOfFacets = _predefinedRangeIndexes.Length;
}
BigSegmentedArray rangeCount = new LazyBigIntArray(_predefinedRangeIndexes.Length);
for (int k = 0; k < _predefinedRangeIndexes.Length; ++k)
{
int count = 0;
int idx = _predefinedRangeIndexes[k][0];
int end = _predefinedRangeIndexes[k][1];
while (idx <= end)
{
count += _count.Get(idx++);
}
rangeCount.Add(k, count);
}
List <BrowseFacet> facetColl;
FacetSpec.FacetSortSpec sortspec = _ospec.OrderBy;
if (sortspec == FacetSpec.FacetSortSpec.OrderValueAsc)
{
facetColl = new List <BrowseFacet>(maxNumOfFacets);
for (int k = 0; k < _predefinedRangeIndexes.Length; ++k)
{
if (rangeCount.Get(k) >= minCount)
{
BrowseFacet choice = new BrowseFacet(_predefinedRanges.Get(k), rangeCount.Get(k));
facetColl.Add(choice);
}
if (facetColl.Count >= maxNumOfFacets)
{
break;
}
}
}
else //if (sortspec == FacetSortSpec.OrderHitsDesc)
{
IComparatorFactory comparatorFactory;
if (sortspec == FacetSpec.FacetSortSpec.OrderHitsDesc)
{
comparatorFactory = new FacetHitcountComparatorFactory();
}
else
{
comparatorFactory = _ospec.CustomComparatorFactory;
}
if (comparatorFactory == null)
{
throw new ArgumentException("facet comparator factory not specified");
}
IComparer <int> comparator = comparatorFactory.NewComparator(new RangeFacetCountCollectorFieldAccessor(_predefinedRanges), rangeCount);
int forbidden = -1;
IntBoundedPriorityQueue pq = new IntBoundedPriorityQueue(comparator, maxNumOfFacets, forbidden);
for (int i = 0; i < _predefinedRangeIndexes.Length; ++i)
{
if (rangeCount.Get(i) >= minCount)
{
pq.Offer(i);
}
}
int val;
facetColl = new List <BrowseFacet>();
while ((val = pq.Poll()) != forbidden)
{
BrowseFacet facet = new BrowseFacet(_predefinedRanges.ElementAt(val), rangeCount.Get(val));
facetColl.Insert(0, facet);
}
}
return(facetColl);
}
else
{
return(FacetCountCollector_Fields.EMPTY_FACET_LIST);
}
}
else
{
return(FacetCountCollector_Fields.EMPTY_FACET_LIST);
}
}
private void ProcessCommand(string line)
{
if (string.IsNullOrEmpty(line))
{
return;
}
string[] parsed = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (parsed.Length == 0)
{
return;
}
string cmd = parsed[0];
string[] args = new string[parsed.Length - 1];
if (args.Length > 0)
{
Array.Copy(parsed, 1, args, 0, args.Length);
}
if ("help".Equals(cmd, StringComparison.OrdinalIgnoreCase) || "?".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine(@"help or ? - prints this message");
Console.WriteLine(@"exit or q - quits");
Console.WriteLine(@"query <query string> - sets query text");
Console.WriteLine(@"facetspec <name>:<minHitCount>,<maxCount>,<isExpand>,<orderby> - add facet spec");
Console.WriteLine(@"page <offset>:<count> - set paging parameters");
Console.WriteLine(@"select <name>:<value1>,<value2>... - add selection, with ! in front of value indicates a not");
Console.WriteLine(@"sort <name>:<dir>,... - set sort specs (false for ascending, true for descending)");
Console.WriteLine(@"showReq: shows current request");
Console.WriteLine(@"clear: clears current request");
Console.WriteLine(@"clearSelections: clears all selections");
Console.WriteLine(@"clearSelection <name>: clear selection specified");
Console.WriteLine(@"clearFacetSpecs: clears all facet specs");
Console.WriteLine(@"clearFacetSpec <name>: clears specified facetspec");
Console.WriteLine(@"browse - executes a search");
}
else if ("query".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length < 2)
{
Console.WriteLine(@"query not defined.");
}
else
{
string queryString = parsed[1];
if (!string.IsNullOrEmpty(queryString))
{
var qparser = new QueryParser(Lucene.Net.Util.Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT));
Query q;
try
{
q = qparser.Parse(queryString);
_reqBuilder.Request.Query = q;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
}
else if ("facetspec".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length < 2)
{
Console.WriteLine("facetspec not defined.");
}
else
{
try
{
string fspecString = parsed[1];
string[] parts = fspecString.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
string name = parts[0];
string fvalue = parts[1];
string[] valParts = fvalue.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (valParts.Length != 4)
{
Console.WriteLine(@"spec must of of the form <minhitcount>,<maxcount>,<isExpand>,<orderby>");
}
else
{
int minHitCount = 1;
int maxCount = 5;
bool expand = false;
FacetSpec.FacetSortSpec sort = FacetSpec.FacetSortSpec.OrderHitsDesc;
try
{
minHitCount = int.Parse(valParts[0]);
}
catch
{
Console.WriteLine("default min hitcount = 1 is applied.");
}
try
{
maxCount = int.Parse(valParts[1]);
}
catch
{
Console.WriteLine("default maxCount = 5 is applied.");
}
try
{
expand = bool.Parse(valParts[2]);
}
catch
{
Console.WriteLine("default expand=false is applied.");
}
if ("hits".Equals(valParts[3]))
{
sort = FacetSpec.FacetSortSpec.OrderHitsDesc;
}
else
{
sort = FacetSpec.FacetSortSpec.OrderValueAsc;
}
_reqBuilder.ApplyFacetSpec(name, minHitCount, maxCount, expand, sort);
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
else if ("select".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length < 2)
{
Console.WriteLine("selection not defined.");
}
else
{
try
{
string selString = parsed[1];
string[] parts = selString.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
string name = parts[0];
string selList = parts[1];
string[] sels = selList.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string sel in sels)
{
bool isNot = false;
string val = sel;
if (sel.StartsWith("!"))
{
isNot = true;
val = sel.Substring(1);
}
if (!string.IsNullOrEmpty(val))
{
_reqBuilder.AddSelection(name, val, isNot);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
else if ("page".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
try
{
string pageString = parsed[1];
string[] parts = pageString.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
_reqBuilder.Offset = int.Parse(parts[0]);
_reqBuilder.Count = int.Parse(parts[1]);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
else if ("clearFacetSpec".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length < 2)
{
Console.WriteLine("facet spec not defined.");
}
else
{
string name = parsed[1];
_reqBuilder.ClearFacetSpec(name);
}
}
else if ("clearSelection".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length < 2)
{
Console.WriteLine("selection name not defined.");
}
else
{
string name = parsed[1];
_reqBuilder.ClearSelection(name);
}
}
else if ("clearSelections".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
_reqBuilder.ClearSelections();
}
else if ("clearFacetSpecs".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
_reqBuilder.ClearFacetSpecs();
}
else if ("clear".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
_reqBuilder.Clear();
}
else if ("showReq".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
BrowseRequest req = _reqBuilder.Request;
Console.WriteLine(req.ToString());
}
else if ("sort".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
if (parsed.Length == 2)
{
string sortString = parsed[1];
string[] sorts = sortString.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var sortList = new List <SortField>();
foreach (var sort in sorts)
{
string[] sortParams = sort.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
bool rev = false;
if (sortParams.Length > 0)
{
string sortName = sortParams[0];
if (sortParams.Length > 1)
{
try
{
rev = bool.Parse(sortParams[1]);
}
catch (Exception e)
{
Console.WriteLine(e.Message + ", default rev to false");
}
}
sortList.Add(new SortField(sortName, SortField.STRING, rev));
}
}
_reqBuilder.ApplySort(sortList.ToArray());
}
else
{
_reqBuilder.ApplySort(null);
}
}
else if ("browse".Equals(cmd, StringComparison.OrdinalIgnoreCase))
{
BrowseRequest req = _reqBuilder.Request;
BrowseResult res = _svc.Browse(req);
string output = BrowseResultFormatter.FormatResults(res);
Console.WriteLine(output);
}
else
{
Console.WriteLine("Unknown command: " + cmd + ", do help for list of supported commands");
}
}
