|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
FacetsAccumulator whose behavior regarding complements, sampling,
etc.AdaptiveFacetsAccumulator
AdaptiveFacetsAccumulator
CategoryAttribute.
CategoryEnhancements to the indexing parameters
CategoryProperty class which is retained when creating
parent tokens.
Collector), for processing the categories
belonging to a certain document.CategoryPath.appendTo(Appendable, char), but takes only a prefix of the
path, rather than the whole path.
CategoryPath.appendTo(Appendable, char), but takes only a part of the
path, rather than the whole path.
CategoryEnhancement for adding associations data to the index
(categories with AssociationPropertys).AssociationProperty which treats the association as float - the
association bits are actually float bits, and thus merging two associations
is done by float summation.Aggregator which updates the weight of a category by summing the
weights of the float association it finds for every document.AssociationProperty which treats the association as int - merges
two associations by summation.Aggregator which updates the weight of a category by summing the
weights of the integer association it finds for every document.CategoryProperty associating a single integer value to a
CategoryAttribute.AssociationProperty.
number.
hashFactor.
hashFactor.
hashFactor
.
hashFactor
.
hashFactor.
hashFactor.
hashFactor.
hashFactor.
CategoryPath
and additional properties.CategoryAttribute.Iterable of CategoryPath objects
into an Iterable of CategoryAttribute objects, which can be
used to construct a CategoryAttributesStream.Iterable of
CategoryAttribute.CategoryDocumentBuilder.setCategories(Iterable).CategoryPaths or
CategoryAttributes to a given document using a taxonomy.FacetIndexingParams or
the default implementation DefaultFacetIndexingParams.CategoryDocumentBuilder.CategoryDocumentBuilder(TaxonomyWriter, FacetIndexingParams)
CategoryListData, per CategoryListParams.CategoryListParams.DEFAULT_TERM.
Term.
CategoryAttributesStream.CategoryAttributes during indexing.CharTermAttributes and
PayloadAttributes of category tokens.CategoryDocumentBuilder.CategoryPath.copyToCharArray(char[], int, int, char) or
CategoryPath.appendTo(Appendable, char).
IntEncoder which encodes values in chunks.TaxonomyWriterCache using CompactLabelToOrdinal.CategoryAttribute attribute
before setting the parent attributes.
CategoryAttribute.
IndexWriter,
which commits whatever changes made to it to the underlying
Directory.
CountingAggregator used during complement counting.CategoryListTokenizer for facet countingScoredDocIdCollector with the given parameters.
ScoredDocIDs which returns document IDs all non-deleted doc ids
according to the given reader.
FacetResultsHandler that matches the request logic
and current settings, such as depth,
limits-mode, etc, as well as the passed in
TaxonomyReader.
IndexWriterConfig that would be used for opening the internal index writer.
IntDecoder which matches this encoder.
bytes, beginning at offset pos.pos.
in.
EnhancementsIndexingParamsenhancement
enhancements
and CategoryListParams
FacetIndexingParams.TaxonomyWriterCache to use in constructors
which do not specify one.
CategoryAttributes from the given
ObjectInputStream.
IntDecoder which wraps another IntDecoder and reverts the
d-gap that was encoded by DGapIntEncoder.IntEncoderFilter which encodes the gap between the given values,
rather than the values themselves.TaxonomyReader which retrieves stored taxonomy information from a
Directory.Directory.
TaxonomyWriter which uses a Directory to store the taxonomy
information on disk, and keeps an additional in-memory cache of some or all
categories.DirectoryTaxonomyWriter.defaultTaxonomyWriterCache().
DirectoryTaxonomyWriter.OrdinalMap maintained on file systemDirectoryTaxonomyWriter.OrdinalMap maintained in memoryFacetsAccumulator.setComplementThreshold(double) will disable using complement optimization.
EightFlagsIntEncoder.ChunksIntEncoder which encodes data in chunks of 8.indicator while larger
values are saved for later encoding in the encodeQueue.
reInit
number to out.
number into dest, starting at offset start from
the beginning of the array.
CategoryEnhancements defined in the given
EnhancementsIndexingParams.EnhancementsDocumentBuilder is a CategoryDocumentBuilder
which adds categories to documents according to the list of
CategoryEnhancements from EnhancementsIndexingParams.Facet indexing parameters for defining
category enhancements.PayloadIterator for iterating over category posting lists generated
using EnhancementsCategoryTokenizer.AlreadyClosedException if it is.
Object.equals(Object), as it is
used in
EnhancementsPayloadIterator.getCategoryData(CategoryEnhancement).
CategoryPath.serializeAppendTo(Appendable)) in the given buffer, at the given
offset.
CategoryPath.equalsToSerialized(CharSequence, int), but compare to
a prefix of the CategoryPath, instead of the whole CategoryPath.
FacetRequest.getNumLabel() and
FacetRequest.getNumResults().PayloadProcessorProvider for updating facets ordinal references,
based on an ordinal map.FacetResult to be generated, and that belong to the given
partition, so that values can be examined and collected.
CategoryDocumentBuilder.build(Document).
FacetIndexingParams object
size,
keeping around a pool of up to maxArrays old arrays.
FacetsAccumulator.setComplementThreshold(double) will force using complement optimization.
FourFlagsIntEncoder.ChunksIntEncoder which encodes values in chunks of 4.CategoryListData for a given CategoryListParams.
TaxonomyWriterCache.get(CategoryPath), but for a given prefix of the
category path.
AssociationsPayloadIterator.setNextDoc(int).
CategoryAttribute this container has for a certain
category, or null if the category is not in the container.
null if no such enhancement exists.
Aggregator and a CategoryListIterator for each
and every FacetRequest.
CategoryListTokenizer which generates the category list for
this enhancement.
CategoryTokenizer to create the category tokens.
TaxonomyReader.ChildrenArrays object which can
be used together to efficiently enumerate the children of any category.
CountingListTokenizer for creating counting list token.
DefaultFacetIndexingParams.DEFAULT_FACET_DELIM_CHAR as the delimiter.
FacetRequest objects, determining what to count.
facet request.
root facet result node,
up till the requested depth, which are valid by the
results handler in effect.
CategoryProperty classes to be retained when
creating CategoryParentsStream.
CategoryProperty class to be retained when creating
CategoryParentsStream.
SamplingParams.getSampleRatio()
in effect.
Term who's payload holds the category-list.
CategoryListParams.equals(Object), in that it uses
the term that defines this category list to derive the hashcode.
CategoryPath.hashCode(), but find the hash function of a prefix with the
given number of components, rather than of the entire path.
CategoryPath.serializeAppendTo(Appendable)) a character buffer.
FacetsAccumulator to be used.
ScoredDocIdCollector to be used as the first phase of
the facet collection.
Heap.pop()
length,
keeping around a pool of up to maxArrays old arrays.
InputStream.OutputStream.IntEncoder which is served as a filter
on the values to encode.FacetResult of faceted search.IntHashSet.
FacetRequest,
such as FacetRequest.getNumLabel().
TotalFacetCounts matching input parameters from the provided outputFile
and add them into the cache for the provided indexReader, taxonomy, and facetIndexingParams.
CategoryListData.
CategoryPath.longHashCode(), but find the hash function of a prefix with
the given number of components, rather than of the entire path.
TaxonomyWriterCache - good choice for huge taxonomies.Vint8.
CategoryContainer to this one.
IntermediateFacetResult-s into one of the
same format
CategoryListIterators, consuming the provided
iterators in order.CategoryListIterator.skipTo(int), or a number higher than Integer.MAX_VALUE.
Integer.MAX_VALUE only if all
iterators are exhausted
NOnesIntEncoder.FourFlagsIntEncoder which translates the data as
follows:
Values ≥ 2 are trnalsated to value+1 (2 ⇒ 3, 3
⇒ 4 and so forth).IndexReader from the internal IndexWriter, by
calling IndexReader.open(IndexWriter, boolean).
CategoryParentsStream, where a given
category ordinal is added to the stream, and than its parents are being added
one after the other using TaxonomyWriter.getParent(int).CategoryProperty holding the ordinal from the taxonomy of the
current category in CategoryAttribute.CategoryParentsStream, where a given
category is added to the stream, and than all its parents are being
added one after the other by successively removing the last component.PerDimensionIndexingParams.addCategoryListParams(CategoryPath, CategoryListParams)CategoryListParams as the default
CategoryListParams for unspecified CategoryPaths.
Heap.pop() is called no other Heap.add(Object) or
Heap.insertWithOverflow(Object) should be called.
TaxonomyWriterCache.put(CategoryPath, int), but for a given prefix of the
category path.
FacetSearchParams
CategoryListData.
OutputStream.
Double.NaN if the none existed.
Float.NaN if the none existed.
SamplingParams
SamplingParams
Collector which stores all docIDs and their scores in a
ScoredDocIDs instance.Aggregator which updates the weight of a category according to the
scores of the documents it was found in.CategoryPath.serializeAppendTo(Appendable), but writes only a
prefix of the CategoryPath.
CategoryAttributes to the given
ObjectOutputStream.CategoryPropertys are Serializable, but do not
assume that Lucene's Attributes are as well
CategoryAttribute from another
CategoryAttribute object.
DirectoryTaxonomyReader.getPath(int) and DirectoryTaxonomyReader.getOrdinal(CategoryPath).
Iterable of
CategoryAttribute objects.
Iterable of
CategoryPath objects.
CategoryPath.serializeAppendTo(Appendable).
Aggregator.aggregate(int) calls will pertain to.
TaxonomyReader.ROOT_ORDINAL.
TaxonomyReader.ROOT_ORDINAL.
TaxonomyReader.ROOT_ORDINAL.
SimpleIntEncoder.IntEncoder, writing an integer as 4 raw bytes.false
IntEncoderFilter which sorts the values to encode in ascending
order before encoding them.FacetsAccumulator, utilizing partitions to save on memory.TotalFacetCounts matching input parameters into the provided outputFile,
making them available for a later call to TotalFacetCountsCache.load(File, IndexReader, TaxonomyReader, FacetIndexingParams).
TaxonomyWriter for adding categories and retrieving their
ordinals.
TaxonomyWriter for adding categories and retrieving their
ordinals.
DirectoryTaxonomyWriter).maxObjects old objects.
FacetResult from the count arrays aggregated for a particular
FacetRequest.Object.toString()
interface, is to allow simple printing of a CategoryPath, for debugging
purposes.
CategoryPath.toString(char), but takes only a prefix with a given number
of components, rather than the whole path.
CategoryPath.toString(char), but takes only a part of the path, rather
than the whole path.
TotalFacetCounts per index, taxonomy, and
facet indexing params.Sampler.overSampledSearchParams(FacetSearchParams).
IntEncoderFilter which ensures only unique values are encoded.ByteArrayInputStream uses a given buffer as a
source of an InputStream.OutputStream.UnsafeByteArrayOutputStream.toByteArray().
minSampleSize <= maxSampleSize <= samplingThreshold
0 < samplingRatio <= 1
initialPosition.
IntDecoder which can decode values encoded by
VInt8IntEncoder.IntEncoder which implements variable length encoding.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||