Lucene.Net.Core: Renamed all type-derived classes and interfaces from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8b7f4185 Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8b7f4185 Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8b7f4185 Branch: refs/heads/api-work Commit: 8b7f4185cf3ae4bd5fe9ca43ce11e21017df14cd Parents: f0cd424 Author: Shad Storhaug <[email protected]> Authored: Wed Feb 8 02:19:45 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Wed Feb 8 21:08:22 2017 +0700 ---------------------------------------------------------------------- .../Analysis/CharFilter/NormalizeCharMap.cs | 2 +- .../Analysis/Hunspell/Dictionary.cs | 44 ++-- .../Analysis/Hunspell/Stemmer.cs | 8 +- .../Miscellaneous/StemmerOverrideFilter.cs | 2 +- .../Analysis/Synonym/SynonymMap.cs | 2 +- .../BlockTerms/FixedGapTermsIndexReader.cs | 24 +- .../BlockTerms/FixedGapTermsIndexWriter.cs | 10 +- .../BlockTerms/VariableGapTermsIndexReader.cs | 6 +- .../BlockTerms/VariableGapTermsIndexWriter.cs | 6 +- .../Memory/DirectDocValuesProducer.cs | 4 +- .../Memory/FSTOrdTermsReader.cs | 2 +- .../Memory/FSTOrdTermsWriter.cs | 10 +- src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs | 4 +- .../Memory/MemoryDocValuesConsumer.cs | 28 +-- .../Memory/MemoryDocValuesFormat.cs | 2 +- .../Memory/MemoryDocValuesProducer.cs | 34 +-- .../Memory/MemoryPostingsFormat.cs | 8 +- .../SimpleText/SimpleTextFieldsReader.cs | 8 +- .../Codecs/BlockTreeTermsWriter.cs | 18 +- .../CompressingStoredFieldsIndexReader.cs | 18 +- .../CompressingStoredFieldsIndexWriter.cs | 22 +- .../CompressingStoredFieldsReader.cs | 12 +- .../CompressingStoredFieldsWriter.cs | 10 +- .../Compressing/CompressingTermVectorsReader.cs | 30 +-- .../Compressing/CompressingTermVectorsWriter.cs | 22 +- src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs | 12 +- src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs | 10 +- .../Codecs/Lucene3x/Lucene3xNormsProducer.cs | 4 +- .../Codecs/Lucene3x/TermInfosReaderIndex.cs | 6 +- .../Codecs/Lucene40/Lucene40DocValuesReader.cs | 46 ++-- src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs | 46 ++-- .../Codecs/Lucene41/Lucene41PostingsReader.cs | 18 +- .../Codecs/Lucene41/Lucene41PostingsWriter.cs | 23 +- .../Codecs/Lucene42/Lucene42DocValuesFormat.cs | 6 +- .../Lucene42/Lucene42DocValuesProducer.cs | 40 ++-- .../Codecs/Lucene42/Lucene42NormsConsumer.cs | 16 +- .../Codecs/Lucene42/Lucene42NormsFormat.cs | 6 +- .../Lucene45/Lucene45DocValuesConsumer.cs | 16 +- .../Lucene45/Lucene45DocValuesProducer.cs | 57 ++--- src/Lucene.Net.Core/Document/DateTools.cs | 2 +- src/Lucene.Net.Core/Document/Document.cs | 4 +- src/Lucene.Net.Core/Document/DoubleField.cs | 2 +- src/Lucene.Net.Core/Document/Field.cs | 2 +- .../Document/FloatDocValuesField.cs | 20 +- src/Lucene.Net.Core/Document/FloatField.cs | 14 +- .../Document/IntDocValuesField.cs | 13 +- src/Lucene.Net.Core/Document/IntField.cs | 14 +- .../Document/LongDocValuesField.cs | 7 +- src/Lucene.Net.Core/Document/LongField.cs | 14 +- .../Document/PackedLongDocValuesField.cs | 11 +- .../Document/ShortDocValuesField.cs | 11 +- src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs | 4 +- .../Index/BinaryDocValuesFieldUpdates.cs | 8 +- .../Index/BinaryDocValuesWriter.cs | 10 +- src/Lucene.Net.Core/Index/BufferedUpdates.cs | 10 +- .../Index/BufferedUpdatesStream.cs | 4 +- src/Lucene.Net.Core/Index/CheckIndex.cs | 4 +- src/Lucene.Net.Core/Index/DocumentsWriter.cs | 2 +- .../Index/DocumentsWriterFlushQueue.cs | 2 +- .../Index/DocumentsWriterPerThread.cs | 21 +- src/Lucene.Net.Core/Index/IndexReader.cs | 2 +- src/Lucene.Net.Core/Index/IndexWriter.cs | 4 +- src/Lucene.Net.Core/Index/MergeState.cs | 8 +- src/Lucene.Net.Core/Index/MultiDocValues.cs | 20 +- .../Index/NumericDocValuesFieldUpdates.cs | 6 +- .../Index/NumericDocValuesWriter.cs | 10 +- src/Lucene.Net.Core/Index/ReadersAndUpdates.cs | 2 +- src/Lucene.Net.Core/Index/SegmentCoreReaders.cs | 2 +- .../Index/SortedDocValuesWriter.cs | 6 +- .../Index/SortedSetDocValuesWriter.cs | 20 +- src/Lucene.Net.Core/Index/TermsHash.cs | 6 +- src/Lucene.Net.Core/Index/TermsHashPerField.cs | 20 +- .../Index/TrackingIndexWriter.cs | 2 +- .../Search/DocTermOrdsRewriteMethod.cs | 8 +- src/Lucene.Net.Core/Search/FieldCache.cs | 117 ++++++---- src/Lucene.Net.Core/Search/FieldCacheImpl.cs | 218 ++++++++++--------- .../Search/FieldCacheRangeFilter.cs | 56 ++--- .../Search/FieldCacheRewriteMethod.cs | 8 +- src/Lucene.Net.Core/Search/FieldComparator.cs | 58 ++--- src/Lucene.Net.Core/Search/MultiPhraseQuery.cs | 11 +- src/Lucene.Net.Core/Search/NumericRangeQuery.cs | 20 +- .../Search/Similarities/BM25Similarity.cs | 10 +- .../Search/Similarities/DefaultSimilarity.cs | 8 +- .../Search/Similarities/SimilarityBase.cs | 6 +- src/Lucene.Net.Core/Search/SortField.cs | 16 +- src/Lucene.Net.Core/Store/RAMDirectory.cs | 2 +- src/Lucene.Net.Core/Support/AtomicInteger.cs | 9 +- src/Lucene.Net.Core/Support/AtomicLong.cs | 9 +- src/Lucene.Net.Core/Support/Buffer.cs | 2 +- src/Lucene.Net.Core/Support/ByteBuffer.cs | 34 +-- src/Lucene.Net.Core/Support/LongBuffer.cs | 81 +++---- .../Support/MemoryMappedFileByteBuffer.cs | 2 +- .../Util/Automaton/BasicOperations.cs | 12 +- .../Util/Automaton/MinimizationOperations.cs | 17 +- .../Util/Automaton/SortedIntSet.cs | 51 +++-- .../Util/Automaton/SpecialOperations.cs | 12 +- src/Lucene.Net.Core/Util/BytesRefHash.cs | 2 +- src/Lucene.Net.Core/Util/FixedBitSet.cs | 2 +- src/Lucene.Net.Core/Util/Fst/Builder.cs | 12 +- src/Lucene.Net.Core/Util/Fst/FST.cs | 18 +- .../Util/Fst/IntSequenceOutputs.cs | 36 +-- src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs | 36 +-- src/Lucene.Net.Core/Util/Fst/NodeHash.cs | 6 +- .../Util/Fst/PositiveIntOutputs.cs | 12 +- src/Lucene.Net.Core/Util/Fst/Util.cs | 34 +-- src/Lucene.Net.Core/Util/IntBlockPool.cs | 40 ++-- src/Lucene.Net.Core/Util/IntsRef.cs | 32 +-- src/Lucene.Net.Core/Util/LongBitSet.cs | 34 +-- src/Lucene.Net.Core/Util/LongValues.cs | 9 +- src/Lucene.Net.Core/Util/LongsRef.cs | 26 ++- .../Util/Mutable/MutableValueDate.cs | 2 +- .../Util/Mutable/MutableValueFloat.cs | 15 +- .../Util/Mutable/MutableValueInt.cs | 15 +- .../Util/Mutable/MutableValueLong.cs | 15 +- src/Lucene.Net.Core/Util/NumericUtils.cs | 22 +- src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs | 38 ++-- .../Util/Packed/AbstractAppendingLongBuffer.cs | 21 +- .../Util/Packed/AbstractBlockPackedWriter.cs | 6 +- .../Util/Packed/AbstractPagedMutable.cs | 18 +- .../Packed/AppendingDeltaPackedLongBuffer.cs | 26 ++- .../Util/Packed/AppendingPackedLongBuffer.cs | 26 ++- .../Util/Packed/BlockPackedReader.cs | 20 +- .../Util/Packed/BlockPackedReaderIterator.cs | 14 +- .../Util/Packed/BlockPackedWriter.cs | 6 +- .../Util/Packed/BulkOperation.cs | 8 +- .../Util/Packed/BulkOperationPacked.cs | 6 +- .../Packed/BulkOperationPackedSingleBlock.cs | 2 +- src/Lucene.Net.Core/Util/Packed/Direct16.cs | 4 +- src/Lucene.Net.Core/Util/Packed/Direct32.cs | 4 +- src/Lucene.Net.Core/Util/Packed/Direct64.cs | 2 +- src/Lucene.Net.Core/Util/Packed/Direct8.cs | 4 +- .../Packed/DirectPacked64SingleBlockReader.cs | 2 +- .../Util/Packed/DirectPackedReader.cs | 2 +- .../Util/Packed/GrowableWriter.cs | 20 +- .../Util/Packed/MonotonicAppendingLongBuffer.cs | 26 ++- .../Util/Packed/MonotonicBlockPackedReader.cs | 20 +- .../Util/Packed/MonotonicBlockPackedWriter.cs | 4 +- .../Util/Packed/Packed16ThreeBlocks.cs | 4 +- src/Lucene.Net.Core/Util/Packed/Packed64.cs | 16 +- .../Util/Packed/Packed64SingleBlock.cs | 12 +- .../Util/Packed/Packed8ThreeBlocks.cs | 4 +- .../Util/Packed/PackedDataInput.cs | 2 +- .../Util/Packed/PackedDataOutput.cs | 2 +- src/Lucene.Net.Core/Util/Packed/PackedInts.cs | 54 ++--- .../Util/Packed/PackedReaderIterator.cs | 14 +- src/Lucene.Net.Core/Util/Packed/PackedWriter.cs | 12 +- .../Util/Packed/PagedGrowableWriter.cs | 4 +- src/Lucene.Net.Core/Util/Packed/PagedMutable.cs | 14 +- .../Util/RecyclingIntBlockAllocator.cs | 27 ++- src/Lucene.Net.Core/Util/SentinelIntSet.cs | 12 +- src/Lucene.Net.Core/Util/SmallFloat.cs | 6 +- src/Lucene.Net.Core/Util/UnicodeUtil.cs | 2 +- src/Lucene.Net.Core/Util/WAH8DocIdSet.cs | 20 +- src/Lucene.Net.Expressions/SimpleBindings.cs | 6 +- src/Lucene.Net.Facet/FacetsConfig.cs | 6 +- .../Range/DoubleRangeFacetCounts.cs | 2 +- .../Taxonomy/CachedOrdinalsReader.cs | 6 +- .../Directory/DirectoryTaxonomyWriter.cs | 2 +- .../Taxonomy/DocValuesOrdinalsReader.cs | 6 +- src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs | 6 +- .../Taxonomy/TaxonomyFacetCounts.cs | 4 +- .../Taxonomy/TaxonomyFacetSumValueSource.cs | 4 +- src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs | 2 +- .../Term/TermAllGroupHeadsCollector.cs | 12 +- .../Term/TermAllGroupsCollector.cs | 4 +- .../Term/TermDistinctValuesCollector.cs | 4 +- .../Term/TermGroupFacetCollector.cs | 4 +- .../Term/TermSecondPassGroupingCollector.cs | 4 +- .../MemoryIndex.MemoryIndexReader.cs | 4 +- src/Lucene.Net.Memory/MemoryIndex.cs | 14 +- src/Lucene.Net.Misc/Index/Sorter/Sorter.cs | 10 +- .../Index/Sorter/SortingMergePolicy.cs | 10 +- src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs | 4 +- .../Util/Fst/UpToTwoPositiveIntOutputs.cs | 2 +- .../Function/DocValues/FloatDocValues.cs | 4 +- .../Function/DocValues/IntDocValues.cs | 4 +- .../Function/DocValues/LongDocValues.cs | 4 +- .../Function/FunctionValues.cs | 4 +- .../Function/ValueSources/EnumFieldSource.cs | 16 +- .../Function/ValueSources/FloatFieldSource.cs | 12 +- .../Function/ValueSources/IntFieldSource.cs | 18 +- .../ValueSources/JoinDocFreqValueSource.cs | 2 +- .../Function/ValueSources/LongFieldSource.cs | 14 +- .../Function/ValueSources/OrdFieldSource.cs | 4 +- .../Function/ValueSources/QueryValueSource.cs | 4 +- .../Function/ValueSources/ShortFieldSource.cs | 8 +- .../Queries/SlowFuzzyTermsEnum.cs | 2 +- .../Prefix/ContainsPrefixTreeFilter.cs | 4 +- .../Spell/LuceneLevenshteinDistance.cs | 8 +- .../Suggest/Analyzing/AnalyzingSuggester.cs | 14 +- .../Suggest/Analyzing/FSTUtil.cs | 12 +- .../Suggest/Analyzing/FreeTextSuggester.cs | 12 +- .../Suggest/Analyzing/FuzzySuggester.cs | 2 +- .../Suggest/Fst/FSTCompletionBuilder.cs | 4 +- .../Suggest/Fst/WFSTCompletionLookup.cs | 6 +- .../asserting/AssertingDocValuesFormat.cs | 4 +- .../Codecs/compressing/FastCompressingCodec.cs | 4 +- .../FastDecompressionCompressingCodec.cs | 4 +- .../HighCompressionCompressingCodec.cs | 4 +- .../Codecs/lucene40/Lucene40DocValuesWriter.cs | 22 +- .../lucene42/Lucene42DocValuesConsumer.cs | 26 +-- .../Codecs/ramonly/RAMOnlyPostingsFormat.cs | 2 +- .../BaseCompressingDocValuesFormatTestCase.cs | 4 +- .../Index/BaseDocValuesFormatTestCase.cs | 4 +- .../Index/BaseStoredFieldsFormatTestCase.cs | 22 +- .../ThreadedIndexingAndSearchingTestCase.cs | 16 +- .../Store/MockDirectoryWrapper.cs | 2 +- .../Util/LineFileDocs.cs | 2 +- src/Lucene.Net.TestFramework/Util/TestUtil.cs | 12 +- .../Util/fst/FSTTester.cs | 72 +++--- .../Analysis/Hunspell/TestDictionary.cs | 10 +- .../TestExpressionSorts.cs | 8 +- .../Range/TestRangeFacetCounts.cs | 16 +- .../Taxonomy/Directory/TestAddTaxonomy.cs | 6 +- .../Directory/TestConcurrentFacetedIndexing.cs | 6 +- .../Directory/TestDirectoryTaxonomyWriter.cs | 6 +- .../Taxonomy/TestTaxonomyFacetSumValueSource.cs | 24 +- .../AllGroupHeadsCollectorTest.cs | 4 +- src/Lucene.Net.Tests.Grouping/TestGrouping.cs | 10 +- .../Highlight/HighlighterTest.cs | 8 +- src/Lucene.Net.Tests.Join/TestBlockJoin.cs | 4 +- .../Util/Fst/TestFSTsMisc.cs | 16 +- .../Function/TestDocValuesFieldSources.cs | 2 +- .../TestCustomScoreQuery.cs | 6 +- .../Flexible/Standard/TestNumericQueryParser.cs | 12 +- .../Xml/TestParser.cs | 2 +- src/Lucene.Net.Tests.Spatial/SpatialExample.cs | 2 +- .../Suggest/Analyzing/FuzzySuggesterTest.cs | 12 +- .../TestCompressingStoredFieldsFormat.cs | 4 +- .../core/Codecs/Lucene41/TestForUtil.cs | 4 +- .../core/Document/TestDocument.cs | 4 +- src/Lucene.Net.Tests/core/Document/TestField.cs | 8 +- .../core/Index/TestBackwardsCompatibility.cs | 16 +- .../core/Index/TestBackwardsCompatibility3x.cs | 16 +- .../core/Index/TestBinaryDocValuesUpdates.cs | 6 +- .../core/Index/TestConcurrentMergeScheduler.cs | 6 +- .../core/Index/TestDirectoryReader.cs | 4 +- .../core/Index/TestDocTermOrds.cs | 8 +- .../core/Index/TestDocValuesWithThreads.cs | 2 +- .../Index/TestDocumentsWriterDeleteQueue.cs | 6 +- .../core/Index/TestFlushByRamOrCountsPolicy.cs | 12 +- .../core/Index/TestForceMergeForever.cs | 2 +- .../core/Index/TestIndexReaderClose.cs | 6 +- .../core/Index/TestIndexWriter.cs | 4 +- .../core/Index/TestIndexWriterDelete.cs | 6 +- .../core/Index/TestIndexWriterReader.cs | 4 +- .../core/Index/TestIntBlockPool.cs | 26 +-- .../core/Index/TestMixedDocValuesUpdates.cs | 6 +- .../core/Index/TestMultiLevelSkipList.cs | 6 +- .../core/Index/TestNRTReaderWithThreads.cs | 2 +- .../core/Index/TestNumericDocValuesUpdates.cs | 6 +- .../core/Index/TestPostingsOffsets.cs | 6 +- .../core/Index/TestStressNRT.cs | 14 +- .../core/Index/TestTermsEnum.cs | 6 +- .../core/Search/JustCompileSearch.cs | 2 +- .../core/Search/TestBooleanOr.cs | 6 +- .../core/Search/TestDocValuesScoring.cs | 10 +- .../core/Search/TestFieldCache.cs | 64 +++--- .../core/Search/TestLiveFieldValues.cs | 4 +- .../Search/TestMultiValuedNumericRangeQuery.cs | 4 +- .../core/Search/TestNumericRangeQuery32.cs | 24 +- .../core/Search/TestNumericRangeQuery64.cs | 14 +- .../core/Search/TestSearchAfter.cs | 16 +- .../core/Search/TestSearchWithThreads.cs | 6 +- src/Lucene.Net.Tests/core/Search/TestSort.cs | 8 +- .../core/Search/TestSortDocValues.cs | 22 +- .../core/Search/TestSortRandom.cs | 2 +- .../core/Search/TestTopDocsMerge.cs | 8 +- .../core/Support/TestByteBuffer.cs | 2 +- .../core/Support/TestLongBuffer.cs | 68 +++--- .../Util/Automaton/TestSpecialOperations.cs | 6 +- src/Lucene.Net.Tests/core/Util/Fst/Test2BFST.cs | 26 +-- src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs | 150 ++++++------- .../core/Util/Packed/TestPackedInts.cs | 186 ++++++++-------- src/Lucene.Net.Tests/core/Util/TestIntsRef.cs | 10 +- .../core/Util/TestLongBitSet.cs | 62 +++--- .../core/Util/TestNumericUtils.cs | 10 +- .../core/Util/TestRecyclingIntBlockAllocator.cs | 12 +- .../core/Util/TestSentinelIntSet.cs | 4 +- .../core/Util/TestSmallFloat.cs | 32 +-- .../core/Util/TestUnicodeUtil.cs | 2 +- 281 files changed, 2146 insertions(+), 1980 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs index 6678922..c4113a4 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs @@ -118,7 +118,7 @@ namespace Lucene.Net.Analysis.CharFilters { Outputs<CharsRef> outputs = CharSequenceOutputs.Singleton; Builder<CharsRef> builder = new Builder<CharsRef>(FST.INPUT_TYPE.BYTE2, outputs); - IntsRef scratch = new IntsRef(); + Int32sRef scratch = new Int32sRef(); foreach (var ent in pendingPairs) { builder.Add(Lucene.Net.Util.Fst.Util.ToUTF16(ent.Key, scratch), new CharsRef(ent.Value)); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs index 0fa0f34..8cf3503 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs @@ -56,8 +56,8 @@ namespace Lucene.Net.Analysis.Hunspell private const string PREFIX_CONDITION_REGEX_PATTERN = "{0}.*"; private const string SUFFIX_CONDITION_REGEX_PATTERN = ".*{0}"; - internal FST<IntsRef> prefixes; - internal FST<IntsRef> suffixes; + internal FST<Int32sRef> prefixes; + internal FST<Int32sRef> suffixes; // all condition checks used by prefixes and suffixes. these are typically re-used across // many affix stripping rules. so these are deduplicated, to save RAM. @@ -65,7 +65,7 @@ namespace Lucene.Net.Analysis.Hunspell // the entries in the .dic file, mapping to their set of flags. // the fst output is the ordinal list for flagLookup - internal FST<IntsRef> words; + internal FST<Int32sRef> words; // the list of unique flagsets (wordforms). theoretically huge, but practically // small (e.g. for polish this is 756), otherwise humans wouldn't be able to deal with it either. internal BytesRefHash flagLookup = new BytesRefHash(); @@ -157,8 +157,8 @@ namespace Lucene.Net.Analysis.Hunspell } // read dictionary entries - IntSequenceOutputs o = IntSequenceOutputs.Singleton; - Builder<IntsRef> b = new Builder<IntsRef>(FST.INPUT_TYPE.BYTE4, o); + Int32SequenceOutputs o = Int32SequenceOutputs.Singleton; + Builder<Int32sRef> b = new Builder<Int32sRef>(FST.INPUT_TYPE.BYTE4, o); ReadDictionaryFiles(dictionaries, decoder, b); words = b.Finish(); aliases = null; // no longer needed @@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis.Hunspell /// <summary> /// Looks up Hunspell word forms from the dictionary /// </summary> - internal virtual IntsRef LookupWord(char[] word, int offset, int length) + internal virtual Int32sRef LookupWord(char[] word, int offset, int length) { return Lookup(words, word, offset, length); } @@ -188,7 +188,7 @@ namespace Lucene.Net.Analysis.Hunspell /// <param name="offset"> Offset in the <see cref="char"/> array that the <see cref="string"/> starts at </param> /// <param name="length"> Length from the offset that the <see cref="string"/> is </param> /// <returns> List of HunspellAffix prefixes with an append that matches the <see cref="string"/>, or <c>null</c> if none are found </returns> - internal virtual IntsRef LookupPrefix(char[] word, int offset, int length) + internal virtual Int32sRef LookupPrefix(char[] word, int offset, int length) { return Lookup(prefixes, word, offset, length); } @@ -200,24 +200,24 @@ namespace Lucene.Net.Analysis.Hunspell /// <param name="offset"> Offset in the char array that the <see cref="string"/> starts at </param> /// <param name="length"> Length from the offset that the <see cref="string"/> is </param> /// <returns> List of HunspellAffix suffixes with an append that matches the <see cref="string"/>, or <c>null</c> if none are found </returns> - internal virtual IntsRef LookupSuffix(char[] word, int offset, int length) + internal virtual Int32sRef LookupSuffix(char[] word, int offset, int length) { return Lookup(suffixes, word, offset, length); } // TODO: this is pretty stupid, considering how the stemming algorithm works // we can speed it up to be significantly faster! - internal virtual IntsRef Lookup(FST<IntsRef> fst, char[] word, int offset, int length) + internal virtual Int32sRef Lookup(FST<Int32sRef> fst, char[] word, int offset, int length) { if (fst == null) { return null; } FST.BytesReader bytesReader = fst.GetBytesReader(); - FST.Arc<IntsRef> arc = fst.GetFirstArc(new FST.Arc<IntsRef>()); + FST.Arc<Int32sRef> arc = fst.GetFirstArc(new FST.Arc<Int32sRef>()); // Accumulate output as we go - IntsRef NO_OUTPUT = fst.Outputs.NoOutput; - IntsRef output = NO_OUTPUT; + Int32sRef NO_OUTPUT = fst.Outputs.NoOutput; + Int32sRef output = NO_OUTPUT; int l = offset + length; try @@ -371,17 +371,17 @@ namespace Lucene.Net.Analysis.Hunspell stripOffsets[currentIndex] = currentOffset; } - private FST<IntsRef> AffixFST(SortedDictionary<string, IList<char?>> affixes) + private FST<Int32sRef> AffixFST(SortedDictionary<string, IList<char?>> affixes) { - IntSequenceOutputs outputs = IntSequenceOutputs.Singleton; - Builder<IntsRef> builder = new Builder<IntsRef>(FST.INPUT_TYPE.BYTE4, outputs); + Int32SequenceOutputs outputs = Int32SequenceOutputs.Singleton; + Builder<Int32sRef> builder = new Builder<Int32sRef>(FST.INPUT_TYPE.BYTE4, outputs); - IntsRef scratch = new IntsRef(); + Int32sRef scratch = new Int32sRef(); foreach (KeyValuePair<string, IList<char?>> entry in affixes) { Lucene.Net.Util.Fst.Util.ToUTF32(entry.Key, scratch); IList<char?> entries = entry.Value; - IntsRef output = new IntsRef(entries.Count); + Int32sRef output = new Int32sRef(entries.Count); foreach (char? c in entries) { output.Int32s[output.Length++] = c.HasValue ? c.Value : 0; @@ -566,7 +566,7 @@ namespace Lucene.Net.Analysis.Hunspell Outputs<CharsRef> outputs = CharSequenceOutputs.Singleton; Builder<CharsRef> builder = new Builder<CharsRef>(FST.INPUT_TYPE.BYTE2, outputs); - IntsRef scratchInts = new IntsRef(); + Int32sRef scratchInts = new Int32sRef(); foreach (KeyValuePair<string, string> entry in mappings) { Lucene.Net.Util.Fst.Util.ToUTF16(entry.Key, scratchInts); @@ -737,10 +737,10 @@ namespace Lucene.Net.Analysis.Hunspell /// <param name="decoder"> <see cref="Encoding"/> used to decode the contents of the file </param> /// <param name="words"></param> /// <exception cref="IOException"> Can be thrown while reading from the file </exception> - private void ReadDictionaryFiles(IList<Stream> dictionaries, Encoding decoder, Builder<IntsRef> words) + private void ReadDictionaryFiles(IList<Stream> dictionaries, Encoding decoder, Builder<Int32sRef> words) { BytesRef flagsScratch = new BytesRef(); - IntsRef scratchInts = new IntsRef(); + Int32sRef scratchInts = new Int32sRef(); StringBuilder sb = new StringBuilder(); @@ -805,7 +805,7 @@ namespace Lucene.Net.Analysis.Hunspell // either way the trick is to encode them as char... but they must be parsed differently string currentEntry = null; - IntsRef currentOrds = new IntsRef(); + Int32sRef currentOrds = new Int32sRef(); string line2; while (reader.Read(scratchLine)) @@ -872,7 +872,7 @@ namespace Lucene.Net.Analysis.Hunspell if (cmp > 0 || currentEntry == null) { currentEntry = entry; - currentOrds = new IntsRef(); // must be this way + currentOrds = new Int32sRef(); // must be this way } currentOrds.Grow(currentOrds.Length + 1); currentOrds.Int32s[currentOrds.Length++] = ord; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs index 2c0d0d7..5feb587 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs @@ -83,7 +83,7 @@ namespace Lucene.Net.Analysis.Hunspell } List<CharsRef> stems = new List<CharsRef>(); - IntsRef forms = dictionary.LookupWord(word, 0, length); + Int32sRef forms = dictionary.LookupWord(word, 0, length); if (forms != null) { // TODO: some forms should not be added, e.g. ONLYINCOMPOUND @@ -179,7 +179,7 @@ namespace Lucene.Net.Analysis.Hunspell { for (int i = length - 1; i >= 0; i--) { - IntsRef prefixes = dictionary.LookupPrefix(word, 0, i); + Int32sRef prefixes = dictionary.LookupPrefix(word, 0, i); if (prefixes == null) { continue; @@ -248,7 +248,7 @@ namespace Lucene.Net.Analysis.Hunspell { for (int i = 0; i < length; i++) { - IntsRef suffixes = dictionary.LookupSuffix(word, i, length - i); + Int32sRef suffixes = dictionary.LookupSuffix(word, i, length - i); if (suffixes == null) { continue; @@ -373,7 +373,7 @@ namespace Lucene.Net.Analysis.Hunspell List<CharsRef> stems = new List<CharsRef>(); - IntsRef forms = dictionary.LookupWord(strippedWord, 0, length); + Int32sRef forms = dictionary.LookupWord(strippedWord, 0, length); if (forms != null) { for (int i = 0; i < forms.Length; i++) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs index 2eec23f..10139ea 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/StemmerOverrideFilter.cs @@ -216,7 +216,7 @@ namespace Lucene.Net.Analysis.Miscellaneous ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton; Builder<BytesRef> builder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE4, outputs); int[] sort = hash.Sort(BytesRef.UTF8SortedAsUnicodeComparer); - IntsRef intsSpare = new IntsRef(); + Int32sRef intsSpare = new Int32sRef(); int size = hash.Count; for (int i = 0; i < size; i++) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs index ac487cd..8fd98ce 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs @@ -273,7 +273,7 @@ namespace Lucene.Net.Analysis.Synonym #pragma warning restore 612, 618 - IntsRef scratchIntsRef = new IntsRef(); + Int32sRef scratchIntsRef = new Int32sRef(); //System.out.println("fmap.build"); for (int keyIdx = 0; keyIdx < sortedKeys.Length; keyIdx++) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs index 4fdb5fe..3254635 100644 --- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs +++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs @@ -341,12 +341,12 @@ namespace Lucene.Net.Codecs.BlockTerms /// <summary> /// Offset into index TermBytes /// </summary> - internal PackedInts.Reader TermOffsets { get; private set; } + internal PackedInt32s.Reader TermOffsets { get; private set; } /// <summary> /// Index pointers into main terms dict /// </summary> - internal PackedInts.Reader TermsDictOffsets { get; private set; } + internal PackedInt32s.Reader TermsDictOffsets { get; private set; } internal int NumIndexTerms { get; private set; } internal long TermsStart { get; private set; } @@ -380,11 +380,11 @@ namespace Lucene.Net.Codecs.BlockTerms fgtir._termBytes.Copy(clone, numTermBytes); // records offsets into main terms dict file - TermsDictOffsets = PackedInts.GetReader(clone); + TermsDictOffsets = PackedInt32s.GetReader(clone); Debug.Assert(TermsDictOffsets.Count == numIndexTerms); // records offsets into byte[] term data - TermOffsets = PackedInts.GetReader(clone); + TermOffsets = PackedInt32s.GetReader(clone); Debug.Assert(TermOffsets.Count == 1 + numIndexTerms); } finally @@ -403,23 +403,23 @@ namespace Lucene.Net.Codecs.BlockTerms // Subsample the index terms clone1.Seek(packedIndexStart); - PackedInts.IReaderIterator termsDictOffsetsIter = PackedInts.GetReaderIterator(clone1, - PackedInts.DEFAULT_BUFFER_SIZE); + PackedInt32s.IReaderIterator termsDictOffsetsIter = PackedInt32s.GetReaderIterator(clone1, + PackedInt32s.DEFAULT_BUFFER_SIZE); clone2.Seek(packedOffsetsStart); - PackedInts.IReaderIterator termOffsetsIter = PackedInts.GetReaderIterator(clone2, - PackedInts.DEFAULT_BUFFER_SIZE); + PackedInt32s.IReaderIterator termOffsetsIter = PackedInt32s.GetReaderIterator(clone2, + PackedInt32s.DEFAULT_BUFFER_SIZE); // TODO: often we can get by w/ fewer bits per // value, below.. .but this'd be more complex: // we'd have to try @ fewer bits and then grow // if we overflowed it. - PackedInts.Mutable termsDictOffsetsM = PackedInts.GetMutable(NumIndexTerms, - termsDictOffsetsIter.BitsPerValue, PackedInts.DEFAULT); - PackedInts.Mutable termOffsetsM = PackedInts.GetMutable(NumIndexTerms + 1, - termOffsetsIter.BitsPerValue, PackedInts.DEFAULT); + PackedInt32s.Mutable termsDictOffsetsM = PackedInt32s.GetMutable(NumIndexTerms, + termsDictOffsetsIter.BitsPerValue, PackedInt32s.DEFAULT); + PackedInt32s.Mutable termOffsetsM = PackedInt32s.GetMutable(NumIndexTerms + 1, + termOffsetsIter.BitsPerValue, PackedInt32s.DEFAULT); TermsDictOffsets = termsDictOffsetsM; TermOffsets = termOffsetsM; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs index 39d3209..1e8fefb 100644 --- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs +++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs @@ -192,9 +192,9 @@ namespace Lucene.Net.Codecs.BlockTerms // write primary terms dict offsets packedIndexStart = outerInstance.m_output.FilePointer; - PackedInts.Writer w = PackedInts.GetWriter(outerInstance.m_output, numIndexTerms, - PackedInts.BitsRequired(termsFilePointer), - PackedInts.DEFAULT); + PackedInt32s.Writer w = PackedInt32s.GetWriter(outerInstance.m_output, numIndexTerms, + PackedInt32s.BitsRequired(termsFilePointer), + PackedInt32s.DEFAULT); // relative to our indexStart long upto = 0; @@ -208,8 +208,8 @@ namespace Lucene.Net.Codecs.BlockTerms packedOffsetsStart = outerInstance.m_output.FilePointer; // write offsets into the byte[] terms - w = PackedInts.GetWriter(outerInstance.m_output, 1 + numIndexTerms, PackedInts.BitsRequired(totTermLength), - PackedInts.DEFAULT); + w = PackedInt32s.GetWriter(outerInstance.m_output, 1 + numIndexTerms, PackedInt32s.BitsRequired(totTermLength), + PackedInt32s.DEFAULT); upto = 0; for (int i = 0; i < numIndexTerms; i++) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs index fb75734..b90c689 100644 --- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs +++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs @@ -33,7 +33,7 @@ namespace Lucene.Net.Codecs.BlockTerms /// </summary> public class VariableGapTermsIndexReader : TermsIndexReaderBase { - private readonly PositiveIntOutputs _fstOutputs = PositiveIntOutputs.Singleton; + private readonly PositiveInt32Outputs _fstOutputs = PositiveInt32Outputs.Singleton; private readonly int _indexDivisor; private readonly IndexInput _input; // Closed if indexLoaded is true: @@ -207,8 +207,8 @@ namespace Lucene.Net.Codecs.BlockTerms if (outerInstance._indexDivisor > 1) { // subsample - var scratchIntsRef = new IntsRef(); - var outputs = PositiveIntOutputs.Singleton; + var scratchIntsRef = new Int32sRef(); + var outputs = PositiveInt32Outputs.Singleton; var builder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, outputs); var fstEnum = new BytesRefFSTEnum<long?>(fst); var count = outerInstance._indexDivisor; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs index 1089fa8..fae7620 100644 --- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs +++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs @@ -247,12 +247,12 @@ namespace Lucene.Net.Codecs.BlockTerms { this.outerInstance = outerInstance; FieldInfo = fieldInfo; - PositiveIntOutputs fstOutputs = PositiveIntOutputs.Singleton; + PositiveInt32Outputs fstOutputs = PositiveInt32Outputs.Singleton; _fstBuilder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, fstOutputs); IndexStart = this.outerInstance.m_output.FilePointer; // Always put empty string in - _fstBuilder.Add(new IntsRef(), termsFilePointer); + _fstBuilder.Add(new Int32sRef(), termsFilePointer); _startTermsFilePointer = termsFilePointer; } @@ -270,7 +270,7 @@ namespace Lucene.Net.Codecs.BlockTerms return false; } - private readonly IntsRef _scratchIntsRef = new IntsRef(); + private readonly Int32sRef _scratchIntsRef = new Int32sRef(); public override void Add(BytesRef text, TermStats stats, long termsFilePointer) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs index fa1c9b2..a216109 100644 --- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs +++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs @@ -45,7 +45,7 @@ namespace Lucene.Net.Codecs.Memory private readonly IDictionary<int?, IBits> docsWithFieldInstances = new Dictionary<int?, IBits>(); private readonly int maxDoc; - private readonly AtomicLong ramBytesUsed; + private readonly AtomicInt64 ramBytesUsed; private readonly int version; internal const sbyte NUMBER = 0; @@ -63,7 +63,7 @@ namespace Lucene.Net.Codecs.Memory string metaName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name, state.SegmentSuffix, metaExtension); // read in the entries from the metadata file. ChecksumIndexInput @in = state.Directory.OpenChecksumInput(metaName, state.Context); - ramBytesUsed = new AtomicLong(RamUsageEstimator.ShallowSizeOfInstance(this.GetType())); + ramBytesUsed = new AtomicInt64(RamUsageEstimator.ShallowSizeOfInstance(this.GetType())); bool success = false; try { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs index 6ceb94c..f57f31f 100644 --- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs +++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs @@ -79,7 +79,7 @@ namespace Lucene.Net.Codecs.Memory long sumDocFreq = blockIn.ReadVInt64(); int docCount = blockIn.ReadVInt32(); int longsSize = blockIn.ReadVInt32(); - var index = new FST<long?>(indexIn, PositiveIntOutputs.Singleton); + var index = new FST<long?>(indexIn, PositiveInt32Outputs.Singleton); var current = new TermsReader(this, fieldInfo, blockIn, numTerms, sumTotalTermFreq, sumDocFreq, docCount, longsSize, index); TermsReader previous; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/FSTOrdTermsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsWriter.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsWriter.cs index c3ecb3d..d313348 100644 --- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsWriter.cs +++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsWriter.cs @@ -29,9 +29,9 @@ namespace Lucene.Net.Codecs.Memory using IndexFileNames = Index.IndexFileNames; using IndexOptions = Index.IndexOptions; using IndexOutput = Store.IndexOutput; - using IntsRef = Util.IntsRef; + using Int32sRef = Util.Int32sRef; using IOUtils = Util.IOUtils; - using PositiveIntOutputs = Util.Fst.PositiveIntOutputs; + using PositiveInt32Outputs = Util.Fst.PositiveInt32Outputs; using RAMOutputStream = Store.RAMOutputStream; using SegmentWriteState = Index.SegmentWriteState; using Util = Util.Fst.Util; @@ -275,12 +275,12 @@ namespace Lucene.Net.Codecs.Memory private readonly FSTOrdTermsWriter _outerInstance; private readonly Builder<long?> _builder; - private readonly PositiveIntOutputs _outputs; + private readonly PositiveInt32Outputs _outputs; private readonly FieldInfo _fieldInfo; private readonly int _longsSize; private long _numTerms; - private readonly IntsRef _scratchTerm = new IntsRef(); + private readonly Int32sRef _scratchTerm = new Int32sRef(); private readonly RAMOutputStream _statsOut = new RAMOutputStream(); private readonly RAMOutputStream _metaLongsOut = new RAMOutputStream(); private readonly RAMOutputStream _metaBytesOut = new RAMOutputStream(); @@ -300,7 +300,7 @@ namespace Lucene.Net.Codecs.Memory _numTerms = 0; _fieldInfo = fieldInfo; _longsSize = outerInstance.postingsWriter.SetField(fieldInfo); - _outputs = PositiveIntOutputs.Singleton; + _outputs = PositiveInt32Outputs.Singleton; _builder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, _outputs); _lastBlockStatsFp = 0; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs b/src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs index 29cadfb..7f13d8c 100644 --- a/src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs +++ b/src/Lucene.Net.Codecs/Memory/FSTTermsWriter.cs @@ -28,7 +28,7 @@ namespace Lucene.Net.Codecs.Memory using IndexFileNames = Index.IndexFileNames; using IndexOptions = Index.IndexOptions; using IndexOutput = Store.IndexOutput; - using IntsRef = Util.IntsRef; + using Int32sRef = Util.Int32sRef; using IOUtils = Util.IOUtils; using RAMOutputStream = Store.RAMOutputStream; using SegmentWriteState = Index.SegmentWriteState; @@ -238,7 +238,7 @@ namespace Lucene.Net.Codecs.Memory private readonly int _longsSize; private long _numTerms; - private readonly IntsRef _scratchTerm = new IntsRef(); + private readonly Int32sRef _scratchTerm = new Int32sRef(); private readonly RAMOutputStream _statsWriter = new RAMOutputStream(); private readonly RAMOutputStream _metaWriter = new RAMOutputStream(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs index 94224fc..aeb0237 100644 --- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs +++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs @@ -29,16 +29,16 @@ namespace Lucene.Net.Codecs.Memory using ByteArrayDataOutput = Store.ByteArrayDataOutput; using BytesRef = Util.BytesRef; using FieldInfo = Index.FieldInfo; - using FormatAndBits = Util.Packed.PackedInts.FormatAndBits; + using FormatAndBits = Util.Packed.PackedInt32s.FormatAndBits; using IndexFileNames = Index.IndexFileNames; using IndexOutput = Store.IndexOutput; using INPUT_TYPE = Util.Fst.FST.INPUT_TYPE; - using IntsRef = Util.IntsRef; + using Int32sRef = Util.Int32sRef; using IOUtils = Util.IOUtils; using MathUtil = Util.MathUtil; using MonotonicBlockPackedWriter = Util.Packed.MonotonicBlockPackedWriter; - using PackedInts = Util.Packed.PackedInts; - using PositiveIntOutputs = Util.Fst.PositiveIntOutputs; + using PackedInt32s = Util.Packed.PackedInt32s; + using PositiveInt32Outputs = Util.Fst.PositiveInt32Outputs; using SegmentWriteState = Index.SegmentWriteState; using Util = Util.Fst.Util; @@ -161,8 +161,8 @@ namespace Lucene.Net.Codecs.Memory { // small number of unique values - int bitsPerValue = PackedInts.BitsRequired(uniqueValues.Count - 1); - FormatAndBits formatAndBits = PackedInts.FastestFormatAndBits(maxDoc, bitsPerValue, + int bitsPerValue = PackedInt32s.BitsRequired(uniqueValues.Count - 1); + FormatAndBits formatAndBits = PackedInt32s.FastestFormatAndBits(maxDoc, bitsPerValue, acceptableOverheadRatio); if (formatAndBits.BitsPerValue == 8 && minValue >= sbyte.MinValue && maxValue <= sbyte.MaxValue) { @@ -185,12 +185,12 @@ namespace Lucene.Net.Codecs.Memory encode[decode[i]] = i; } - meta.WriteVInt32(PackedInts.VERSION_CURRENT); + meta.WriteVInt32(PackedInt32s.VERSION_CURRENT); data.WriteVInt32(formatAndBits.Format.Id); data.WriteVInt32(formatAndBits.BitsPerValue); - PackedInts.Writer writer = PackedInts.GetWriterNoHeader(data, formatAndBits.Format, maxDoc, - formatAndBits.BitsPerValue, PackedInts.DEFAULT_BUFFER_SIZE); + PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(data, formatAndBits.Format, maxDoc, + formatAndBits.BitsPerValue, PackedInt32s.DEFAULT_BUFFER_SIZE); foreach (var nv in values) { var v = encode[nv.HasValue ? nv.Value : 0]; @@ -203,7 +203,7 @@ namespace Lucene.Net.Codecs.Memory else if (gcd != 0 && gcd != 1) { meta.WriteByte(MemoryDocValuesProducer.GCD_COMPRESSED); - meta.WriteVInt32(PackedInts.VERSION_CURRENT); + meta.WriteVInt32(PackedInt32s.VERSION_CURRENT); data.WriteInt64(minValue); data.WriteInt64(gcd); data.WriteVInt32(MemoryDocValuesProducer.BLOCK_SIZE); @@ -219,7 +219,7 @@ namespace Lucene.Net.Codecs.Memory { meta.WriteByte(MemoryDocValuesProducer.DELTA_COMPRESSED); // delta-compressed - meta.WriteVInt32(PackedInts.VERSION_CURRENT); + meta.WriteVInt32(PackedInt32s.VERSION_CURRENT); data.WriteVInt32(MemoryDocValuesProducer.BLOCK_SIZE); var writer = new BlockPackedWriter(data, MemoryDocValuesProducer.BLOCK_SIZE); @@ -317,7 +317,7 @@ namespace Lucene.Net.Codecs.Memory // otherwise, we need to record the length fields... if (minLength != maxLength) { - meta.WriteVInt32(PackedInts.VERSION_CURRENT); + meta.WriteVInt32(PackedInt32s.VERSION_CURRENT); meta.WriteVInt32(MemoryDocValuesProducer.BLOCK_SIZE); @@ -340,9 +340,9 @@ namespace Lucene.Net.Codecs.Memory meta.WriteVInt32(field.Number); meta.WriteByte(MemoryDocValuesProducer.FST); meta.WriteInt64(data.FilePointer); - PositiveIntOutputs outputs = PositiveIntOutputs.Singleton; + PositiveInt32Outputs outputs = PositiveInt32Outputs.Singleton; var builder = new Builder<long?>(INPUT_TYPE.BYTE1, outputs); - var scratch = new IntsRef(); + var scratch = new Int32sRef(); long ord = 0; foreach (BytesRef v in values) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs index 80a8b34..9393198 100644 --- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs +++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs @@ -34,7 +34,7 @@ namespace Lucene.Net.Codecs.Memory /// MemoryDocValuesFormat(PackedInts.DEFAULT)} /// </summary> public MemoryDocValuesFormat() - : this(PackedInts.DEFAULT) + : this(PackedInt32s.DEFAULT) { } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs index cab8547..7fd6ca2 100644 --- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs +++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs @@ -48,7 +48,7 @@ namespace Lucene.Net.Codecs.Memory private readonly IDictionary<int?, IBits> docsWithFieldInstances = new Dictionary<int?, IBits>(); private readonly int maxDoc; - private readonly AtomicLong ramBytesUsed; + private readonly AtomicInt64 ramBytesUsed; private readonly int version; internal const byte NUMBER = 0; @@ -93,7 +93,7 @@ namespace Lucene.Net.Codecs.Memory CodecUtil.CheckEOF(@in); #pragma warning restore 612, 618 } - ramBytesUsed = new AtomicLong(RamUsageEstimator.ShallowSizeOfInstance(this.GetType())); + ramBytesUsed = new AtomicInt64(RamUsageEstimator.ShallowSizeOfInstance(this.GetType())); success = true; } finally @@ -251,7 +251,7 @@ namespace Lucene.Net.Codecs.Memory } int formatID = data.ReadVInt32(); int bitsPerValue = data.ReadVInt32(); - var ordsReader = PackedInts.GetReaderNoHeader(data, PackedInts.Format.ById(formatID), + var ordsReader = PackedInt32s.GetReaderNoHeader(data, PackedInt32s.Format.ById(formatID), entry.packedIntsVersion, maxDoc, bitsPerValue); ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed()); return new NumericDocValuesAnonymousInnerClassHelper(this, decode, ordsReader); @@ -285,10 +285,10 @@ namespace Lucene.Net.Codecs.Memory private readonly MemoryDocValuesProducer outerInstance; private readonly long[] decode; - private readonly PackedInts.Reader ordsReader; + private readonly PackedInt32s.Reader ordsReader; public NumericDocValuesAnonymousInnerClassHelper(MemoryDocValuesProducer outerInstance, long[] decode, - PackedInts.Reader ordsReader) + PackedInt32s.Reader ordsReader) { this.outerInstance = outerInstance; this.decode = decode; @@ -429,7 +429,7 @@ namespace Lucene.Net.Codecs.Memory if (!fstInstances.TryGetValue(field.Number, out instance)) { data.Seek(entry.offset); - instance = new FST<long?>(data, PositiveIntOutputs.Singleton); + instance = new FST<long?>(data, PositiveInt32Outputs.Singleton); ramBytesUsed.AddAndGet(instance.SizeInBytes()); fstInstances[field.Number] = instance; } @@ -441,7 +441,7 @@ namespace Lucene.Net.Codecs.Memory var @in = fst.GetBytesReader(); var firstArc = new FST.Arc<long?>(); var scratchArc = new FST.Arc<long?>(); - var scratchInts = new IntsRef(); + var scratchInts = new Int32sRef(); var fstEnum = new BytesRefFSTEnum<long?>(fst); return new SortedDocValuesAnonymousInnerClassHelper(entry, docToOrd, fst, @in, firstArc, scratchArc, @@ -456,12 +456,12 @@ namespace Lucene.Net.Codecs.Memory private readonly FST.BytesReader @in; private readonly FST.Arc<long?> firstArc; private readonly FST.Arc<long?> scratchArc; - private readonly IntsRef scratchInts; + private readonly Int32sRef scratchInts; private readonly BytesRefFSTEnum<long?> fstEnum; public SortedDocValuesAnonymousInnerClassHelper(FSTEntry fstEntry, NumericDocValues numericDocValues, FST<long?> fst1, FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc1, - IntsRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum) + Int32sRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum) { entry = fstEntry; docToOrd = numericDocValues; @@ -484,7 +484,7 @@ namespace Lucene.Net.Codecs.Memory { @in.Position = 0; fst.GetFirstArc(firstArc); - IntsRef output = Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts); + Int32sRef output = Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts); result.Bytes = new byte[output.Length]; result.Offset = 0; result.Length = 0; @@ -544,7 +544,7 @@ namespace Lucene.Net.Codecs.Memory if (!fstInstances.TryGetValue(field.Number, out instance)) { data.Seek(entry.offset); - instance = new FST<long?>(data, PositiveIntOutputs.Singleton); + instance = new FST<long?>(data, PositiveInt32Outputs.Singleton); ramBytesUsed.AddAndGet(instance.SizeInBytes()); fstInstances[field.Number] = instance; } @@ -556,7 +556,7 @@ namespace Lucene.Net.Codecs.Memory var @in = fst.GetBytesReader(); var firstArc = new FST.Arc<long?>(); var scratchArc = new FST.Arc<long?>(); - var scratchInts = new IntsRef(); + var scratchInts = new Int32sRef(); var fstEnum = new BytesRefFSTEnum<long?>(fst); var @ref = new BytesRef(); var input = new ByteArrayDataInput(); @@ -572,7 +572,7 @@ namespace Lucene.Net.Codecs.Memory private readonly FST.BytesReader @in; private readonly FST.Arc<long?> firstArc; private readonly FST.Arc<long?> scratchArc; - private readonly IntsRef scratchInts; + private readonly Int32sRef scratchInts; private readonly BytesRefFSTEnum<long?> fstEnum; private readonly BytesRef @ref; private readonly ByteArrayDataInput input; @@ -580,7 +580,7 @@ namespace Lucene.Net.Codecs.Memory private long currentOrd; public SortedSetDocValuesAnonymousInnerClassHelper(FSTEntry fstEntry, BinaryDocValues binaryDocValues, FST<long?> fst1, - FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc1, IntsRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum, + FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc1, Int32sRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum, BytesRef @ref, ByteArrayDataInput byteArrayDataInput) { entry = fstEntry; @@ -621,7 +621,7 @@ namespace Lucene.Net.Codecs.Memory { @in.Position = 0; fst.GetFirstArc(firstArc); - IntsRef output = Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts); + Int32sRef output = Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts); result.Bytes = new byte[output.Length]; result.Offset = 0; result.Length = 0; @@ -762,7 +762,7 @@ namespace Lucene.Net.Codecs.Memory private readonly FST.BytesReader bytesReader; private readonly FST.Arc<long?> firstArc = new FST.Arc<long?>(); private readonly FST.Arc<long?> scratchArc = new FST.Arc<long?>(); - private readonly IntsRef scratchInts = new IntsRef(); + private readonly Int32sRef scratchInts = new Int32sRef(); private readonly BytesRef scratchBytes = new BytesRef(); internal FSTTermsEnum(FST<long?> fst) @@ -812,7 +812,7 @@ namespace Lucene.Net.Codecs.Memory // but we dont want to introduce a bug that corrupts our enum state! bytesReader.Position = 0; fst.GetFirstArc(firstArc); - IntsRef output = Util.GetByOutput(fst, ord, bytesReader, firstArc, scratchArc, scratchInts); + Int32sRef output = Util.GetByOutput(fst, ord, bytesReader, firstArc, scratchArc, scratchInts); scratchBytes.Bytes = new byte[output.Length]; scratchBytes.Offset = 0; scratchBytes.Length = 0; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs index 50e1116..9ed0949 100644 --- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs +++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs @@ -37,10 +37,10 @@ namespace Lucene.Net.Codecs.Memory using IndexInput = Store.IndexInput; using IndexOptions = Index.IndexOptions; using IndexOutput = Store.IndexOutput; - using IntsRef = Util.IntsRef; + using Int32sRef = Util.Int32sRef; using IOContext = Store.IOContext; using IOUtils = Util.IOUtils; - using PackedInts = Util.Packed.PackedInts; + using PackedInt32s = Util.Packed.PackedInt32s; using RAMOutputStream = Store.RAMOutputStream; using RamUsageEstimator = Util.RamUsageEstimator; using SegmentReadState = Index.SegmentReadState; @@ -77,7 +77,7 @@ namespace Lucene.Net.Codecs.Memory private readonly float acceptableOverheadRatio; public MemoryPostingsFormat() - : this(false, PackedInts.DEFAULT) + : this(false, PackedInt32s.DEFAULT) { } @@ -248,7 +248,7 @@ namespace Lucene.Net.Codecs.Memory private readonly BytesRef spare = new BytesRef(); private byte[] finalBuffer = new byte[128]; - private readonly IntsRef scratchIntsRef = new IntsRef(); + private readonly Int32sRef scratchIntsRef = new Int32sRef(); public override void FinishTerm(BytesRef text, TermStats stats) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs index fbe26ba..09bde88 100644 --- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs +++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs @@ -38,9 +38,9 @@ namespace Lucene.Net.Codecs.SimpleText using IBits = Util.IBits; using IndexInput = Store.IndexInput; using IndexOptions = Index.IndexOptions; - using IntsRef = Util.IntsRef; + using Int32sRef = Util.Int32sRef; using IOUtils = Util.IOUtils; - using PositiveIntOutputs = Util.Fst.PositiveIntOutputs; + using PositiveInt32Outputs = Util.Fst.PositiveInt32Outputs; using SegmentReadState = Index.SegmentReadState; using StringHelper = Util.StringHelper; using Terms = Index.Terms; @@ -596,7 +596,7 @@ namespace Lucene.Net.Codecs.SimpleText private void LoadTerms() { - var posIntOutputs = PositiveIntOutputs.Singleton; + var posIntOutputs = PositiveInt32Outputs.Singleton; var outputsInner = new PairOutputs<long?, long?>(posIntOutputs, posIntOutputs); var outputs = new PairOutputs<long?, PairOutputs<long?,long?>.Pair>(posIntOutputs, outputsInner); @@ -611,7 +611,7 @@ namespace Lucene.Net.Codecs.SimpleText long totalTermFreq = 0; var visitedDocs = new FixedBitSet(_maxDoc); - var scratchIntsRef = new IntsRef(); + var scratchIntsRef = new Int32sRef(); while (true) { SimpleTextUtil.ReadLine(input, _scratch); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/BlockTreeTermsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net.Core/Codecs/BlockTreeTermsWriter.cs index 4541d1d..b026cbf 100644 --- a/src/Lucene.Net.Core/Codecs/BlockTreeTermsWriter.cs +++ b/src/Lucene.Net.Core/Codecs/BlockTreeTermsWriter.cs @@ -31,10 +31,10 @@ namespace Lucene.Net.Codecs using IndexFileNames = Lucene.Net.Index.IndexFileNames; using IndexOptions = Lucene.Net.Index.IndexOptions; using IndexOutput = Lucene.Net.Store.IndexOutput; - using IntsRef = Lucene.Net.Util.IntsRef; + using Int32sRef = Lucene.Net.Util.Int32sRef; using IOUtils = Lucene.Net.Util.IOUtils; using NoOutputs = Lucene.Net.Util.Fst.NoOutputs; - using PackedInts = Lucene.Net.Util.Packed.PackedInts; + using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s; using RAMOutputStream = Lucene.Net.Store.RAMOutputStream; using SegmentWriteState = Lucene.Net.Index.SegmentWriteState; using Util = Lucene.Net.Util.Fst.Util; @@ -413,7 +413,7 @@ namespace Lucene.Net.Codecs public bool HasTerms { get; private set; } public bool IsFloor { get; private set; } public int FloorLeadByte { get; private set; } - private readonly IntsRef scratchIntsRef = new IntsRef(); + private readonly Int32sRef scratchIntsRef = new Int32sRef(); public PendingBlock(BytesRef prefix, long fp, bool hasTerms, bool isFloor, int floorLeadByte, IList<FST<BytesRef>> subIndices) : base(false) @@ -457,7 +457,7 @@ namespace Lucene.Net.Codecs } ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton; - Builder<BytesRef> indexBuilder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE1, 0, 0, true, false, int.MaxValue, outputs, null, false, PackedInts.COMPACT, true, 15); + Builder<BytesRef> indexBuilder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE1, 0, 0, true, false, int.MaxValue, outputs, null, false, PackedInt32s.COMPACT, true, 15); var bytes = new byte[(int)scratchBytes.FilePointer]; Debug.Assert(bytes.Length > 0); scratchBytes.WriteTo(bytes, 0); @@ -562,7 +562,7 @@ namespace Lucene.Net.Codecs this.outerInstance = outerInstance; } - public override void Freeze(Builder.UnCompiledNode<object>[] frontier, int prefixLenPlus1, IntsRef lastInput) + public override void Freeze(Builder.UnCompiledNode<object>[] frontier, int prefixLenPlus1, Int32sRef lastInput) { //if (DEBUG) System.out.println(" freeze prefixLenPlus1=" + prefixLenPlus1); @@ -617,7 +617,7 @@ namespace Lucene.Net.Codecs // primary (initial) block and then one or more // following floor blocks: - internal virtual void WriteBlocks(IntsRef prevTerm, int prefixLength, int count) + internal virtual void WriteBlocks(Int32sRef prevTerm, int prefixLength, int count) { if (prefixLength == 0 || count <= outerInstance.maxItemsInBlock) { @@ -874,7 +874,7 @@ namespace Lucene.Net.Codecs // Writes all entries in the pending slice as a single // block: - private PendingBlock WriteBlock(IntsRef prevTerm, int prefixLength, int indexPrefixLength, int startBackwards, int length, int futureTermCount, bool isFloor, int floorLeadByte, bool isLastInFloor) + private PendingBlock WriteBlock(Int32sRef prevTerm, int prefixLength, int indexPrefixLength, int startBackwards, int length, int futureTermCount, bool isFloor, int floorLeadByte, bool isLastInFloor) { Debug.Assert(length > 0); @@ -1104,7 +1104,7 @@ namespace Lucene.Net.Codecs // this Builder is just used transiently to fragment // terms into "good" blocks; we don't save the // resulting FST: - blockBuilder = new Builder<object>(FST.INPUT_TYPE.BYTE1, 0, 0, true, true, int.MaxValue, noOutputs, new FindBlocks(this), false, PackedInts.COMPACT, true, 15); + blockBuilder = new Builder<object>(FST.INPUT_TYPE.BYTE1, 0, 0, true, true, int.MaxValue, noOutputs, new FindBlocks(this), false, PackedInt32s.COMPACT, true, 15); this.longsSize = outerInstance.postingsWriter.SetField(fieldInfo); } @@ -1131,7 +1131,7 @@ namespace Lucene.Net.Codecs return outerInstance.postingsWriter; } - private readonly IntsRef scratchIntsRef = new IntsRef(); + private readonly Int32sRef scratchIntsRef = new Int32sRef(); public override void FinishTerm(BytesRef text, TermStats stats) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs index 7a07078..a27fc40 100644 --- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs +++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs @@ -22,7 +22,7 @@ namespace Lucene.Net.Codecs.Compressing using CorruptIndexException = Lucene.Net.Index.CorruptIndexException; using IndexInput = Lucene.Net.Store.IndexInput; - using PackedInts = Lucene.Net.Util.Packed.PackedInts; + using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s; using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator; using SegmentInfo = Lucene.Net.Index.SegmentInfo; @@ -42,8 +42,8 @@ namespace Lucene.Net.Codecs.Compressing internal readonly long[] startPointers; internal readonly int[] avgChunkDocs; internal readonly long[] avgChunkSizes; - internal readonly PackedInts.Reader[] docBasesDeltas; // delta from the avg - internal readonly PackedInts.Reader[] startPointersDeltas; // delta from the avg + internal readonly PackedInt32s.Reader[] docBasesDeltas; // delta from the avg + internal readonly PackedInt32s.Reader[] startPointersDeltas; // delta from the avg // It is the responsibility of the caller to close fieldsIndexIn after this constructor // has been called @@ -54,8 +54,8 @@ namespace Lucene.Net.Codecs.Compressing long[] startPointers = new long[16]; int[] avgChunkDocs = new int[16]; long[] avgChunkSizes = new long[16]; - PackedInts.Reader[] docBasesDeltas = new PackedInts.Reader[16]; - PackedInts.Reader[] startPointersDeltas = new PackedInts.Reader[16]; + PackedInt32s.Reader[] docBasesDeltas = new PackedInt32s.Reader[16]; + PackedInt32s.Reader[] startPointersDeltas = new PackedInt32s.Reader[16]; int packedIntsVersion = fieldsIndexIn.ReadVInt32(); @@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Compressing { throw new CorruptIndexException("Corrupted bitsPerDocBase (resource=" + fieldsIndexIn + ")"); } - docBasesDeltas[blockCount] = PackedInts.GetReaderNoHeader(fieldsIndexIn, PackedInts.Format.PACKED, packedIntsVersion, numChunks, bitsPerDocBase); + docBasesDeltas[blockCount] = PackedInt32s.GetReaderNoHeader(fieldsIndexIn, PackedInt32s.Format.PACKED, packedIntsVersion, numChunks, bitsPerDocBase); // start pointers startPointers[blockCount] = fieldsIndexIn.ReadVInt64(); @@ -97,7 +97,7 @@ namespace Lucene.Net.Codecs.Compressing { throw new CorruptIndexException("Corrupted bitsPerStartPointer (resource=" + fieldsIndexIn + ")"); } - startPointersDeltas[blockCount] = PackedInts.GetReaderNoHeader(fieldsIndexIn, PackedInts.Format.PACKED, packedIntsVersion, numChunks, bitsPerStartPointer); + startPointersDeltas[blockCount] = PackedInt32s.GetReaderNoHeader(fieldsIndexIn, PackedInt32s.Format.PACKED, packedIntsVersion, numChunks, bitsPerStartPointer); ++blockCount; } @@ -190,11 +190,11 @@ namespace Lucene.Net.Codecs.Compressing { long res = 0; - foreach (PackedInts.Reader r in docBasesDeltas) + foreach (PackedInt32s.Reader r in docBasesDeltas) { res += r.RamBytesUsed(); } - foreach (PackedInts.Reader r in startPointersDeltas) + foreach (PackedInt32s.Reader r in startPointersDeltas) { res += r.RamBytesUsed(); } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs index 6d7ce28..981e476 100644 --- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs +++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs @@ -21,7 +21,7 @@ namespace Lucene.Net.Codecs.Compressing */ using IndexOutput = Lucene.Net.Store.IndexOutput; - using PackedInts = Lucene.Net.Util.Packed.PackedInts; + using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s; /// <summary> /// Efficient index format for block-based <seealso cref="Codec"/>s. @@ -36,7 +36,7 @@ namespace Lucene.Net.Codecs.Compressing /// <p>Data is written as follows:</p> /// <ul> /// <li>PackedIntsVersion, <Block><sup>BlockCount</sup>, BlocksEndMarker</li> - /// <li>PackedIntsVersion --> <seealso cref="PackedInts#VERSION_CURRENT"/> as a <seealso cref="DataOutput#writeVInt VInt"/></li> + /// <li>PackedIntsVersion --> <seealso cref="PackedInt32s#VERSION_CURRENT"/> as a <seealso cref="DataOutput#writeVInt VInt"/></li> /// <li>BlocksEndMarker --> <tt>0</tt> as a <seealso cref="DataOutput#writeVInt VInt"/>, this marks the end of blocks since blocks are not allowed to start with <tt>0</tt></li> /// <li>Block --> BlockChunks, <DocBases>, <StartPointers></li> /// <li>BlockChunks --> a <seealso cref="DataOutput#writeVInt VInt"/> which is the number of chunks encoded in the block</li> @@ -44,12 +44,12 @@ namespace Lucene.Net.Codecs.Compressing /// <li>DocBase --> first document ID of the block of chunks, as a <seealso cref="DataOutput#writeVInt VInt"/></li> /// <li>AvgChunkDocs --> average number of documents in a single chunk, as a <seealso cref="DataOutput#writeVInt VInt"/></li> /// <li>BitsPerDocBaseDelta --> number of bits required to represent a delta from the average using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> - /// <li>DocBaseDeltas --> <seealso cref="PackedInts packed"/> array of BlockChunks elements of BitsPerDocBaseDelta bits each, representing the deltas from the average doc base using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a>.</li> + /// <li>DocBaseDeltas --> <seealso cref="PackedInt32s packed"/> array of BlockChunks elements of BitsPerDocBaseDelta bits each, representing the deltas from the average doc base using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a>.</li> /// <li>StartPointers --> StartPointerBase, AvgChunkSize, BitsPerStartPointerDelta, StartPointerDeltas</li> /// <li>StartPointerBase --> the first start pointer of the block, as a <seealso cref="DataOutput#writeVLong VLong"/></li> /// <li>AvgChunkSize --> the average size of a chunk of compressed documents, as a <seealso cref="DataOutput#writeVLong VLong"/></li> /// <li>BitsPerStartPointerDelta --> number of bits required to represent a delta from the average using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> - /// <li>StartPointerDeltas --> <seealso cref="PackedInts packed"/> array of BlockChunks elements of BitsPerStartPointerDelta bits each, representing the deltas from the average start pointer using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> + /// <li>StartPointerDeltas --> <seealso cref="PackedInt32s packed"/> array of BlockChunks elements of BitsPerStartPointerDelta bits each, representing the deltas from the average start pointer using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> /// <li>Footer --> <seealso cref="CodecUtil#writeFooter CodecFooter"/></li> /// </ul> /// <p>Notes</p> @@ -90,7 +90,7 @@ namespace Lucene.Net.Codecs.Compressing totalDocs = 0; docBaseDeltas = new int[BLOCK_SIZE]; startPointerDeltas = new long[BLOCK_SIZE]; - fieldsIndexOut.WriteVInt32(PackedInts.VERSION_CURRENT); + fieldsIndexOut.WriteVInt32(PackedInt32s.VERSION_CURRENT); } private void Reset() @@ -133,14 +133,14 @@ namespace Lucene.Net.Codecs.Compressing docBase += docBaseDeltas[i]; } - int bitsPerDocBase = PackedInts.BitsRequired(maxDelta); + int bitsPerDocBase = PackedInt32s.BitsRequired(maxDelta); fieldsIndexOut.WriteVInt32(bitsPerDocBase); - PackedInts.Writer writer = PackedInts.GetWriterNoHeader(fieldsIndexOut, PackedInts.Format.PACKED, blockChunks, bitsPerDocBase, 1); + PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(fieldsIndexOut, PackedInt32s.Format.PACKED, blockChunks, bitsPerDocBase, 1); docBase = 0; for (int i = 0; i < blockChunks; ++i) { long delta = docBase - avgChunkDocs * i; - Debug.Assert(PackedInts.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue); + Debug.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue); writer.Add(MoveSignToLowOrderBit(delta)); docBase += docBaseDeltas[i]; } @@ -167,15 +167,15 @@ namespace Lucene.Net.Codecs.Compressing maxDelta |= MoveSignToLowOrderBit(delta); } - int bitsPerStartPointer = PackedInts.BitsRequired(maxDelta); + int bitsPerStartPointer = PackedInt32s.BitsRequired(maxDelta); fieldsIndexOut.WriteVInt32(bitsPerStartPointer); - writer = PackedInts.GetWriterNoHeader(fieldsIndexOut, PackedInts.Format.PACKED, blockChunks, bitsPerStartPointer, 1); + writer = PackedInt32s.GetWriterNoHeader(fieldsIndexOut, PackedInt32s.Format.PACKED, blockChunks, bitsPerStartPointer, 1); startPointer = 0; for (int i = 0; i < blockChunks; ++i) { startPointer += startPointerDeltas[i]; long delta = startPointer - avgChunkSize * i; - Debug.Assert(PackedInts.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue); + Debug.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue); writer.Add(MoveSignToLowOrderBit(delta)); } writer.Finish(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsReader.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsReader.cs index 7d82d35..6fcb5e9 100644 --- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsReader.cs +++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsReader.cs @@ -37,7 +37,7 @@ namespace Lucene.Net.Codecs.Compressing using IndexInput = Lucene.Net.Store.IndexInput; using IOContext = Lucene.Net.Store.IOContext; using IOUtils = Lucene.Net.Util.IOUtils; - using PackedInts = Lucene.Net.Util.Packed.PackedInts; + using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s; using SegmentInfo = Lucene.Net.Index.SegmentInfo; using StoredFieldVisitor = Lucene.Net.Index.StoredFieldVisitor; @@ -282,9 +282,9 @@ namespace Lucene.Net.Codecs.Compressing else { long filePointer = fieldsStream.FilePointer; - PackedInts.Reader reader = PackedInts.GetDirectReaderNoHeader(fieldsStream, PackedInts.Format.PACKED, packedIntsVersion, chunkDocs, bitsPerStoredFields); + PackedInt32s.Reader reader = PackedInt32s.GetDirectReaderNoHeader(fieldsStream, PackedInt32s.Format.PACKED, packedIntsVersion, chunkDocs, bitsPerStoredFields); numStoredFields = (int)(reader.Get(docID - docBase)); - fieldsStream.Seek(filePointer + PackedInts.Format.PACKED.ByteCount(packedIntsVersion, chunkDocs, bitsPerStoredFields)); + fieldsStream.Seek(filePointer + PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, chunkDocs, bitsPerStoredFields)); } int bitsPerLength = fieldsStream.ReadVInt32(); @@ -300,7 +300,7 @@ namespace Lucene.Net.Codecs.Compressing } else { - PackedInts.IReaderIterator it = PackedInts.GetReaderIteratorNoHeader(fieldsStream, PackedInts.Format.PACKED, packedIntsVersion, chunkDocs, bitsPerLength, 1); + PackedInt32s.IReaderIterator it = PackedInt32s.GetReaderIteratorNoHeader(fieldsStream, PackedInt32s.Format.PACKED, packedIntsVersion, chunkDocs, bitsPerLength, 1); int off = 0; for (int i = 0; i < docID - docBase; ++i) { @@ -541,7 +541,7 @@ namespace Lucene.Net.Codecs.Compressing } else { - PackedInts.IReaderIterator it = PackedInts.GetReaderIteratorNoHeader(fieldsStream, PackedInts.Format.PACKED, outerInstance.packedIntsVersion, chunkDocs, bitsPerStoredFields, 1); + PackedInt32s.IReaderIterator it = PackedInt32s.GetReaderIteratorNoHeader(fieldsStream, PackedInt32s.Format.PACKED, outerInstance.packedIntsVersion, chunkDocs, bitsPerStoredFields, 1); for (int i = 0; i < chunkDocs; ++i) { numStoredFields[i] = (int)it.Next(); @@ -559,7 +559,7 @@ namespace Lucene.Net.Codecs.Compressing } else { - PackedInts.IReaderIterator it = PackedInts.GetReaderIteratorNoHeader(fieldsStream, PackedInts.Format.PACKED, outerInstance.packedIntsVersion, chunkDocs, bitsPerLength, 1); + PackedInt32s.IReaderIterator it = PackedInt32s.GetReaderIteratorNoHeader(fieldsStream, PackedInt32s.Format.PACKED, outerInstance.packedIntsVersion, chunkDocs, bitsPerLength, 1); for (int i = 0; i < chunkDocs; ++i) { lengths[i] = (int)it.Next(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsWriter.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsWriter.cs index b1f722e..1097cb2 100644 --- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsWriter.cs +++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingStoredFieldsWriter.cs @@ -43,8 +43,8 @@ namespace Lucene.Net.Codecs.Compressing internal const int NUMERIC_LONG = 0x04; internal const int NUMERIC_DOUBLE = 0x05; - internal static readonly int TYPE_BITS = PackedInts.BitsRequired(NUMERIC_DOUBLE); - internal static readonly int TYPE_MASK = (int)PackedInts.MaxValue(TYPE_BITS); + internal static readonly int TYPE_BITS = PackedInt32s.BitsRequired(NUMERIC_DOUBLE); + internal static readonly int TYPE_MASK = (int)PackedInt32s.MaxValue(TYPE_BITS); internal const string CODEC_SFX_IDX = "Index"; internal const string CODEC_SFX_DAT = "Data"; @@ -103,7 +103,7 @@ namespace Lucene.Net.Codecs.Compressing indexStream = null; fieldsStream.WriteVInt32(chunkSize); - fieldsStream.WriteVInt32(PackedInts.VERSION_CURRENT); + fieldsStream.WriteVInt32(PackedInt32s.VERSION_CURRENT); success = true; } @@ -187,9 +187,9 @@ namespace Lucene.Net.Codecs.Compressing { max |= (uint)values[i]; } - int bitsRequired = PackedInts.BitsRequired(max); + int bitsRequired = PackedInt32s.BitsRequired(max); @out.WriteVInt32(bitsRequired); - PackedInts.Writer w = PackedInts.GetWriterNoHeader(@out, PackedInts.Format.PACKED, length, bitsRequired, 1); + PackedInt32s.Writer w = PackedInt32s.GetWriterNoHeader(@out, PackedInt32s.Format.PACKED, length, bitsRequired, 1); for (int i = 0; i < length; ++i) { w.Add(values[i]);
