lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [30/53] [abbrv] lucenenet git commit: 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.
Date Wed, 08 Feb 2017 14:32:09 GMT
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 <shad@shadstorhaug.com>
Authored: Wed Feb 8 02:19:45 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
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, &lt;Block&gt;<sup>BlockCount</sup>, BlocksEndMarker</li>
-    /// <li>PackedIntsVersion --&gt; <seealso cref="PackedInts#VERSION_CURRENT"/> as a <seealso cref="DataOutput#writeVInt VInt"/></li>
+    /// <li>PackedIntsVersion --&gt; <seealso cref="PackedInt32s#VERSION_CURRENT"/> as a <seealso cref="DataOutput#writeVInt VInt"/></li>
     /// <li>BlocksEndMarker --&gt; <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 --&gt; BlockChunks, &lt;DocBases&gt;, &lt;StartPointers&gt;</li>
     /// <li>BlockChunks --&gt; 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 --&gt; first document ID of the block of chunks, as a <seealso cref="DataOutput#writeVInt VInt"/></li>
     /// <li>AvgChunkDocs --&gt; average number of documents in a single chunk, as a <seealso cref="DataOutput#writeVInt VInt"/></li>
     /// <li>BitsPerDocBaseDelta --&gt; 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 --&gt; <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 --&gt; <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 --&gt; StartPointerBase, AvgChunkSize, BitsPerStartPointerDelta, StartPointerDeltas</li>
     /// <li>StartPointerBase --&gt; the first start pointer of the block, as a <seealso cref="DataOutput#writeVLong VLong"/></li>
     /// <li>AvgChunkSize --&gt; the average size of a chunk of compressed documents, as a <seealso cref="DataOutput#writeVLong VLong"/></li>
     /// <li>BitsPerStartPointerDelta --&gt; 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 --&gt; <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 --&gt; <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 --&gt; <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]);


Mime
View raw message