lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [34/53] [abbrv] lucenenet git commit: Lucene.Net.Codecs: 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:13 GMT
Lucene.Net.Codecs: 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/d3dfb950
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/d3dfb950
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/d3dfb950

Branch: refs/heads/api-work
Commit: d3dfb9500a8f2af50c8783d141745f568795988c
Parents: 0ff7988
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Wed Feb 8 02:33:23 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Wed Feb 8 21:08:23 2017 +0700

----------------------------------------------------------------------
 .../IntBlock/FixedIntBlockIndexInput.cs         | 10 +++--
 .../IntBlock/FixedIntBlockIndexOutput.cs        | 20 +++++-----
 .../IntBlock/VariableIntBlockIndexInput.cs      | 10 +++--
 .../IntBlock/VariableIntBlockIndexOutput.cs     | 20 +++++-----
 .../Memory/DirectPostingsFormat.cs              |  7 +++-
 src/Lucene.Net.Codecs/Sep/IntIndexInput.cs      | 12 +++---
 src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs     |  4 +-
 src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs   | 12 +++---
 src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs  | 40 ++++++++++----------
 src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs  | 22 +++++------
 src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs  | 30 +++++++--------
 src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs  | 26 ++++++-------
 .../MockFixedIntBlockPostingsFormat.cs          | 14 +++----
 .../MockVariableIntBlockPostingsFormat.cs       | 12 +++---
 .../Codecs/MockSep/MockSingleIntFactory.cs      |  6 +--
 .../Codecs/MockSep/MockSingleIntIndexInput.cs   |  2 +-
 .../Codecs/MockSep/MockSingleIntIndexOutput.cs  |  2 +-
 .../IntBlock/TestIntBlockCodec.cs               | 14 +++----
 18 files changed, 140 insertions(+), 123 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
index 23cbd4c..4cce99b 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
@@ -31,15 +31,17 @@ namespace Lucene.Net.Codecs.IntBlock
     ///  more performant approach would directly create an impl
     ///  of IntIndexInput inside Directory.  Wrapping a generic
     ///  IndexInput will likely cost performance.
+    /// <para/>
+    /// NOTE: This was FixedIntBlockIndexInput in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
-    public abstract class FixedIntBlockIndexInput : IntIndexInput
+    public abstract class FixedInt32BlockIndexInput : Int32IndexInput
     {
         private readonly IndexInput input;
         protected readonly int m_blockSize;
 
-        public FixedIntBlockIndexInput(IndexInput @in)
+        public FixedInt32BlockIndexInput(IndexInput @in)
         {
             input = @in;
             m_blockSize = @in.ReadVInt32();
@@ -132,9 +134,9 @@ namespace Lucene.Net.Codecs.IntBlock
 
         private class Index : AbstractIndex
         {
-            private readonly FixedIntBlockIndexInput outerInstance;
+            private readonly FixedInt32BlockIndexInput outerInstance;
 
-            public Index(FixedIntBlockIndexInput outerInstance)
+            public Index(FixedInt32BlockIndexInput outerInstance)
             {
                 this.outerInstance = outerInstance;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
index 90672d5..b60b70a 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
@@ -21,11 +21,11 @@ namespace Lucene.Net.Codecs.IntBlock
      * limitations under the License.
      */
 
-    /// <summary>
-    /// Naive int block API that writes vInts.  This is
-    ///  expected to give poor performance; it's really only for
-    ///  testing the pluggability.  One should typically use pfor instead. 
-    /// </summary>
+
+    // Naive int block API that writes vInts.  This is
+    //  expected to give poor performance; it's really only for
+    //  testing the pluggability.  One should typically use pfor instead. 
+
 
 
     /// <summary>
@@ -34,17 +34,19 @@ namespace Lucene.Net.Codecs.IntBlock
     ///  more performant approach would directly create an impl
     ///  of IntIndexOutput inside Directory.  Wrapping a generic
     ///  IndexInput will likely cost performance.
+    /// <para/>
+    /// NOTE: This was FixedIntBlockIndexOutput in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
-    public abstract class FixedIntBlockIndexOutput : IntIndexOutput
+    public abstract class FixedInt32BlockIndexOutput : Int32IndexOutput
     {
         protected readonly IndexOutput m_output;
         private readonly int blockSize;
         protected readonly int[] m_buffer;
         private int upto;
 
-        protected FixedIntBlockIndexOutput(IndexOutput output, int fixedBlockSize)
+        protected FixedInt32BlockIndexOutput(IndexOutput output, int fixedBlockSize)
         {
             blockSize = fixedBlockSize;
             this.m_output = output;
@@ -61,9 +63,9 @@ namespace Lucene.Net.Codecs.IntBlock
 
         private class Index : AbstractIndex
         {
-            private readonly FixedIntBlockIndexOutput outerInstance;
+            private readonly FixedInt32BlockIndexOutput outerInstance;
 
-            public Index(FixedIntBlockIndexOutput outerInstance)
+            public Index(FixedInt32BlockIndexOutput outerInstance)
             {
                 this.outerInstance = outerInstance;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
index e388124..1fda534 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
@@ -35,15 +35,17 @@ namespace Lucene.Net.Codecs.IntBlock
     /// more performant approach would directly create an impl
     /// of IntIndexInput inside Directory.  Wrapping a generic
     /// IndexInput will likely cost performance.
+    /// <para/>
+    /// NOTE: This was VariableIntBlockIndexInput in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
-    public abstract class VariableIntBlockIndexInput : IntIndexInput
+    public abstract class VariableInt32BlockIndexInput : Int32IndexInput
     {
         private readonly IndexInput input;
         protected readonly int m_maxBlockSize;
 
-        protected internal VariableIntBlockIndexInput(IndexInput input)
+        protected internal VariableInt32BlockIndexInput(IndexInput input)
         {
             this.input = input;
             m_maxBlockSize = input.ReadInt32();
@@ -165,9 +167,9 @@ namespace Lucene.Net.Codecs.IntBlock
 
         private class Index : AbstractIndex
         {
-            private readonly VariableIntBlockIndexInput outerInstance;
+            private readonly VariableInt32BlockIndexInput outerInstance;
 
-            public Index(VariableIntBlockIndexInput outerInstance)
+            public Index(VariableInt32BlockIndexInput outerInstance)
             {
                 this.outerInstance = outerInstance;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
index b52ae38..a59a6b1 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
@@ -21,11 +21,11 @@ namespace Lucene.Net.Codecs.IntBlock
      * limitations under the License.
      */
 
-    /// <summary>
-    /// Naive int block API that writes vInts.  This is
-    /// expected to give poor performance; it's really only for
-    /// testing the pluggability.  One should typically use pfor instead. 
-    /// </summary>
+
+    // Naive int block API that writes vInts.  This is
+    // expected to give poor performance; it's really only for
+    // testing the pluggability.  One should typically use pfor instead. 
+
 
 
     // TODO: much of this can be shared code w/ the fixed case
@@ -36,10 +36,12 @@ namespace Lucene.Net.Codecs.IntBlock
     ///  more performant approach would directly create an impl
     ///  of IntIndexOutput inside Directory.  Wrapping a generic
     ///  IndexInput will likely cost performance.
+    /// <para/>
+    /// NOTE: This was VariableIntBlockIndexOutput in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
-    public abstract class VariableIntBlockIndexOutput : IntIndexOutput
+    public abstract class VariableInt32BlockIndexOutput : Int32IndexOutput
     {
         protected readonly IndexOutput m_output;
 
@@ -55,7 +57,7 @@ namespace Lucene.Net.Codecs.IntBlock
         ///  requires lookahead=1 because on seeing the Nth value
         ///  it knows it must now encode the N-1 values before it. 
         /// </summary>
-        protected VariableIntBlockIndexOutput(IndexOutput output, int maxBlockSize)
+        protected VariableInt32BlockIndexOutput(IndexOutput output, int maxBlockSize)
         {
             this.m_output = output;
             this.m_output.WriteInt32(maxBlockSize);
@@ -74,9 +76,9 @@ namespace Lucene.Net.Codecs.IntBlock
 
         private class Index : AbstractIndex
         {
-            private readonly VariableIntBlockIndexOutput outerInstance;
+            private readonly VariableInt32BlockIndexOutput outerInstance;
 
-            public Index(VariableIntBlockIndexOutput outerInstance)
+            public Index(VariableInt32BlockIndexOutput outerInstance)
             {
                 this.outerInstance = outerInstance;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
index 063d2f2..6bfbedf 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
@@ -355,7 +355,10 @@ namespace Lucene.Net.Codecs.Memory
             private int[] sameCounts = new int[10];
             private readonly int minSkipCount;
 
-            private sealed class IntArrayWriter
+            /// <summary>
+            /// NOTE: This was IntArrayWriter in Lucene
+            /// </summary>
+            private sealed class Int32ArrayWriter
             {
                 private int[] ints = new int[10];
                 private int upto;
@@ -409,7 +412,7 @@ namespace Lucene.Net.Codecs.Memory
                 TermsEnum termsEnum = termsIn.GetIterator(null);
                 int termOffset = 0;
 
-                IntArrayWriter scratch = new IntArrayWriter();
+                Int32ArrayWriter scratch = new Int32ArrayWriter();
 
                 // Used for payloads, if any:
                 RAMOutputStream ros = new RAMOutputStream();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/IntIndexInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/IntIndexInput.cs b/src/Lucene.Net.Codecs/Sep/IntIndexInput.cs
index 5cc867e..efb853e 100644
--- a/src/Lucene.Net.Codecs/Sep/IntIndexInput.cs
+++ b/src/Lucene.Net.Codecs/Sep/IntIndexInput.cs
@@ -21,20 +21,22 @@ namespace Lucene.Net.Codecs.Sep
      */
 
     /// <summary>
-    /// Defines basic API for writing ints to an IndexOutput.
-    ///  IntBlockCodec interacts with this API. @see
-    ///  IntBlockReader
+    /// Defines basic API for writing ints to an <see cref="IndexOutput"/>.
+    /// IntBlockCodec interacts with this API. @see
+    /// IntBlockReader
+    /// <para/>
+    /// NOTE: This was IntIndexInput in Lucene
     /// 
     /// @lucene.experimental 
     /// </summary>
-    public abstract class IntIndexInput : IDisposable
+    public abstract class Int32IndexInput : IDisposable
     {
         public abstract AbstractReader GetReader();
         public abstract void Dispose();
         public abstract AbstractIndex GetIndex();
 
         /// <summary>
-        /// Records a single skip-point in the <see cref="IntIndexInput.GetReader"/>.
</summary>
+        /// Records a single skip-point in the <see cref="Int32IndexInput.GetReader"/>.
</summary>
         public abstract class AbstractIndex
         {
             public abstract void Read(DataInput indexIn, bool absolute);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs b/src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs
index 2744ae2..65eecec 100644
--- a/src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/Sep/IntIndexOutput.cs
@@ -25,6 +25,8 @@ namespace Lucene.Net.Codecs.Sep
     /// IntBlockCodec interacts with this API. @see IntBlockReader.
     /// 
     /// NOTE: block sizes could be variable
+    /// <para/>
+    /// NOTE: This was IntIndexOutput in Lucene
     /// 
     /// @lucene.experimental 
     /// </summary>
@@ -32,7 +34,7 @@ namespace Lucene.Net.Codecs.Sep
     /// TODO: We may want tighter integration w/IndexOutput
     /// may give better performance
     /// </remarks>
-    public abstract class IntIndexOutput : IDisposable
+    public abstract class Int32IndexOutput : IDisposable
     {
         /// <summary>
         /// Write an int to the primary file.  The value must be

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs b/src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs
index f3f0c49..09f0915 100644
--- a/src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs
+++ b/src/Lucene.Net.Codecs/Sep/IntStreamFactory.cs
@@ -21,19 +21,21 @@ namespace Lucene.Net.Codecs.Sep
 
     /// <summary>
     /// Provides int reader and writer to specified files.
+    /// <para/>
+    /// NOTE: This was IntStreamFactory in Lucene
     /// 
     /// @lucene.experimental 
     /// </summary>
-    public abstract class IntStreamFactory
+    public abstract class Int32StreamFactory
     {
         /// <summary>
-        /// Create an <seealso cref="IntIndexInput"/> on the provided fileName. 
+        /// Create an <seealso cref="Int32IndexInput"/> on the provided fileName. 
         /// </summary>
-        public abstract IntIndexInput OpenInput(Directory dir, string fileName, IOContext
context);
+        public abstract Int32IndexInput OpenInput(Directory dir, string fileName, IOContext
context);
 
         /// <summary>
-        /// Create an <seealso cref="IntIndexOutput"/> on the provided fileName. 
+        /// Create an <seealso cref="Int32IndexOutput"/> on the provided fileName.

         /// </summary>
-        public abstract IntIndexOutput CreateOutput(Directory dir, string fileName, IOContext
context);
+        public abstract Int32IndexOutput CreateOutput(Directory dir, string fileName, IOContext
context);
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
index 97f35db..e4243dd 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
@@ -35,9 +35,9 @@ namespace Lucene.Net.Codecs.Sep
     /// </remarks>
     public class SepPostingsReader : PostingsReaderBase
     {
-        private readonly IntIndexInput _freqIn;
-        private readonly IntIndexInput _docIn;
-        private readonly IntIndexInput _posIn;
+        private readonly Int32IndexInput _freqIn;
+        private readonly Int32IndexInput _docIn;
+        private readonly Int32IndexInput _posIn;
         private readonly IndexInput _payloadIn;
         private readonly IndexInput _skipIn;
 
@@ -46,7 +46,7 @@ namespace Lucene.Net.Codecs.Sep
         private int _skipMinimum;
 
         public SepPostingsReader(Directory dir, FieldInfos fieldInfos, SegmentInfo segmentInfo,
IOContext context,
-            IntStreamFactory intFactory, string segmentSuffix)
+            Int32StreamFactory intFactory, string segmentSuffix)
         {
             var success = false;
             try
@@ -119,9 +119,9 @@ namespace Lucene.Net.Codecs.Sep
             // We store only the seek point to the docs file because
             // the rest of the info (freqIndex, posIndex, etc.) is
             // stored in the docs file:
-            internal IntIndexInput.AbstractIndex DOC_INDEX;
-            internal IntIndexInput.AbstractIndex POS_INDEX;
-            internal IntIndexInput.AbstractIndex FREQ_INDEX;
+            internal Int32IndexInput.AbstractIndex DOC_INDEX;
+            internal Int32IndexInput.AbstractIndex POS_INDEX;
+            internal Int32IndexInput.AbstractIndex FREQ_INDEX;
             internal long PAYLOAD_FP;
             internal long SKIP_FP;
 
@@ -308,14 +308,14 @@ namespace Lucene.Net.Codecs.Sep
             private IndexOptions _indexOptions;
             private bool _storePayloads;
             private IBits _liveDocs;
-            private readonly IntIndexInput.AbstractReader _docReader;
-            private readonly IntIndexInput.AbstractReader _freqReader;
+            private readonly Int32IndexInput.AbstractReader _docReader;
+            private readonly Int32IndexInput.AbstractReader _freqReader;
             private long _skipFp;
 
-            private readonly IntIndexInput.AbstractIndex _docIndex;
-            private readonly IntIndexInput.AbstractIndex _freqIndex;
-            private readonly IntIndexInput.AbstractIndex _posIndex;
-            internal IntIndexInput startDocIn;
+            private readonly Int32IndexInput.AbstractIndex _docIndex;
+            private readonly Int32IndexInput.AbstractIndex _freqIndex;
+            private readonly Int32IndexInput.AbstractIndex _posIndex;
+            internal Int32IndexInput startDocIn;
 
             // TODO: -- should we do hasProx with 2 different enum classes?
 
@@ -485,16 +485,16 @@ namespace Lucene.Net.Codecs.Sep
 
             private bool _storePayloads;
             private IBits _liveDocs;
-            private readonly IntIndexInput.AbstractReader _docReader;
-            private readonly IntIndexInput.AbstractReader _freqReader;
-            private readonly IntIndexInput.AbstractReader _posReader;
+            private readonly Int32IndexInput.AbstractReader _docReader;
+            private readonly Int32IndexInput.AbstractReader _freqReader;
+            private readonly Int32IndexInput.AbstractReader _posReader;
             private readonly IndexInput _payloadIn;
             private long _skipFp;
 
-            private readonly IntIndexInput.AbstractIndex _docIndex;
-            private readonly IntIndexInput.AbstractIndex _freqIndex;
-            private readonly IntIndexInput.AbstractIndex _posIndex;
-            internal IntIndexInput startDocIn;
+            private readonly Int32IndexInput.AbstractIndex _docIndex;
+            private readonly Int32IndexInput.AbstractIndex _freqIndex;
+            private readonly Int32IndexInput.AbstractIndex _posIndex;
+            internal Int32IndexInput startDocIn;
 
             private long _payloadFp;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
index ad2f89f..53dee93 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
@@ -42,14 +42,14 @@ namespace Lucene.Net.Codecs.Sep
         internal const int VERSION_START = 0;
         internal const int VERSION_CURRENT = VERSION_START;
 
-        internal IntIndexOutput freqOut;
-        internal IntIndexOutput.AbstractIndex freqIndex;
+        internal Int32IndexOutput freqOut;
+        internal Int32IndexOutput.AbstractIndex freqIndex;
 
-        internal IntIndexOutput posOut;
-        internal IntIndexOutput.AbstractIndex posIndex;
+        internal Int32IndexOutput posOut;
+        internal Int32IndexOutput.AbstractIndex posIndex;
 
-        internal IntIndexOutput docOut;
-        internal IntIndexOutput.AbstractIndex docIndex;
+        internal Int32IndexOutput docOut;
+        internal Int32IndexOutput.AbstractIndex docIndex;
 
         internal IndexOutput payloadOut;
 
@@ -96,12 +96,12 @@ namespace Lucene.Net.Codecs.Sep
         internal long lastPayloadFP;
         internal long lastSkipFP; 
 
-        public SepPostingsWriter(SegmentWriteState state, IntStreamFactory factory)
+        public SepPostingsWriter(SegmentWriteState state, Int32StreamFactory factory)
             : this(state, factory, DEFAULT_SKIP_INTERVAL)
         {
         }
 
-        public SepPostingsWriter(SegmentWriteState state, IntStreamFactory factory, int skipInterval)
+        public SepPostingsWriter(SegmentWriteState state, Int32StreamFactory factory, int
skipInterval)
         {
             freqOut = null;
             freqIndex = null;
@@ -302,9 +302,9 @@ namespace Lucene.Net.Codecs.Sep
 
         private class SepTermState : BlockTermState
         {
-            public IntIndexOutput.AbstractIndex DocIndex { get; set; }
-            public IntIndexOutput.AbstractIndex FreqIndex { get; set; }
-            public IntIndexOutput.AbstractIndex PosIndex { get; set; }
+            public Int32IndexOutput.AbstractIndex DocIndex { get; set; }
+            public Int32IndexOutput.AbstractIndex FreqIndex { get; set; }
+            public Int32IndexOutput.AbstractIndex PosIndex { get; set; }
             public long PayloadFp { get; set; }
             public long SkipFp { get; set; }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
index aa090b5..09c677f 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
@@ -33,30 +33,30 @@ namespace Lucene.Net.Codecs.Sep
     internal class SepSkipListReader : MultiLevelSkipListReader
     {
         private bool _currentFieldStoresPayloads;
-        private readonly IntIndexInput.AbstractIndex[] _freqIndex;
-        private readonly IntIndexInput.AbstractIndex[] _docIndex;
-        private readonly IntIndexInput.AbstractIndex[] _posIndex;
+        private readonly Int32IndexInput.AbstractIndex[] _freqIndex;
+        private readonly Int32IndexInput.AbstractIndex[] _docIndex;
+        private readonly Int32IndexInput.AbstractIndex[] _posIndex;
         private readonly long[] _payloadPointer;
         private readonly int[] _payloadLength;
 
-        private readonly IntIndexInput.AbstractIndex _lastFreqIndex;
-        private readonly IntIndexInput.AbstractIndex _lastDocIndex;
-        private readonly IntIndexInput.AbstractIndex _lastPosIndex;
+        private readonly Int32IndexInput.AbstractIndex _lastFreqIndex;
+        private readonly Int32IndexInput.AbstractIndex _lastDocIndex;
+        private readonly Int32IndexInput.AbstractIndex _lastPosIndex;
 
         private long _lastPayloadPointer;
         private int _lastPayloadLength;
 
-        internal SepSkipListReader(IndexInput skipStream, IntIndexInput freqIn, IntIndexInput
docIn, IntIndexInput posIn,
+        internal SepSkipListReader(IndexInput skipStream, Int32IndexInput freqIn, Int32IndexInput
docIn, Int32IndexInput posIn,
             int maxSkipLevels, int skipInterval)
             : base(skipStream, maxSkipLevels, skipInterval)
         {
             if (freqIn != null)
-                _freqIndex = new IntIndexInput.AbstractIndex[maxSkipLevels];
+                _freqIndex = new Int32IndexInput.AbstractIndex[maxSkipLevels];
 
-            _docIndex = new IntIndexInput.AbstractIndex[maxSkipLevels];
+            _docIndex = new Int32IndexInput.AbstractIndex[maxSkipLevels];
 
             if (posIn != null)
-                _posIndex = new IntIndexInput.AbstractIndex[m_maxNumberOfSkipLevels];
+                _posIndex = new Int32IndexInput.AbstractIndex[m_maxNumberOfSkipLevels];
 
             for (var i = 0; i < maxSkipLevels; i++)
             {
@@ -84,8 +84,8 @@ namespace Lucene.Net.Codecs.Sep
             _indexOptions = v;
         }
 
-        internal virtual void Init(long skipPointer, IntIndexInput.AbstractIndex docBaseIndex,
IntIndexInput.AbstractIndex freqBaseIndex,
-            IntIndexInput.AbstractIndex posBaseIndex, long payloadBasePointer, int df, bool
storesPayloads)
+        internal virtual void Init(long skipPointer, Int32IndexInput.AbstractIndex docBaseIndex,
Int32IndexInput.AbstractIndex freqBaseIndex,
+            Int32IndexInput.AbstractIndex posBaseIndex, long payloadBasePointer, int df,
bool storesPayloads)
         {
             base.Init(skipPointer, df);
             _currentFieldStoresPayloads = storesPayloads;
@@ -153,17 +153,17 @@ namespace Lucene.Net.Codecs.Sep
                 _posIndex[level - 1].CopyFrom(_posIndex[level]);
         }
 
-        internal virtual IntIndexInput.AbstractIndex FreqIndex
+        internal virtual Int32IndexInput.AbstractIndex FreqIndex
         {
             get { return _lastFreqIndex; }
         }
 
-        internal virtual IntIndexInput.AbstractIndex PosIndex
+        internal virtual Int32IndexInput.AbstractIndex PosIndex
         {
             get { return _lastPosIndex; }
         }
 
-        internal virtual IntIndexInput.AbstractIndex DocIndex
+        internal virtual Int32IndexInput.AbstractIndex DocIndex
         {
             get { return _lastDocIndex; }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
index 6e5bc5c..e596347 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
@@ -38,12 +38,12 @@ namespace Lucene.Net.Codecs.Sep
         private readonly int[] _lastSkipPayloadLength;
         private readonly long[] _lastSkipPayloadPointer;
 
-        private readonly IntIndexOutput.AbstractIndex[] _docIndex;
-        private readonly IntIndexOutput.AbstractIndex[] _freqIndex;
-        private readonly IntIndexOutput.AbstractIndex[] _posIndex;
+        private readonly Int32IndexOutput.AbstractIndex[] _docIndex;
+        private readonly Int32IndexOutput.AbstractIndex[] _freqIndex;
+        private readonly Int32IndexOutput.AbstractIndex[] _posIndex;
 
-        private readonly IntIndexOutput _freqOutput;
-        private IntIndexOutput _posOutput;
+        private readonly Int32IndexOutput _freqOutput;
+        private Int32IndexOutput _posOutput;
         private IndexOutput _payloadOutput;
 
         private int _curDoc;
@@ -51,8 +51,8 @@ namespace Lucene.Net.Codecs.Sep
         private int _curPayloadLength;
         private long _curPayloadPointer;
 
-        internal SepSkipListWriter(int skipInterval, int numberOfSkipLevels, int docCount,
IntIndexOutput freqOutput,
-            IntIndexOutput docOutput, IntIndexOutput posOutput, IndexOutput payloadOutput)
+        internal SepSkipListWriter(int skipInterval, int numberOfSkipLevels, int docCount,
Int32IndexOutput freqOutput,
+            Int32IndexOutput docOutput, Int32IndexOutput posOutput, IndexOutput payloadOutput)
             : base(skipInterval, numberOfSkipLevels, docCount)
         {
 
@@ -65,9 +65,9 @@ namespace Lucene.Net.Codecs.Sep
             // TODO: -- also cutover normal IndexOutput to use getIndex()?
             _lastSkipPayloadPointer = new long[numberOfSkipLevels];
 
-            _freqIndex = new IntIndexOutput.AbstractIndex[numberOfSkipLevels];
-            _docIndex = new IntIndexOutput.AbstractIndex[numberOfSkipLevels];
-            _posIndex = new IntIndexOutput.AbstractIndex[numberOfSkipLevels];
+            _freqIndex = new Int32IndexOutput.AbstractIndex[numberOfSkipLevels];
+            _docIndex = new Int32IndexOutput.AbstractIndex[numberOfSkipLevels];
+            _posIndex = new Int32IndexOutput.AbstractIndex[numberOfSkipLevels];
 
             for (var i = 0; i < numberOfSkipLevels; i++)
             {
@@ -90,7 +90,7 @@ namespace Lucene.Net.Codecs.Sep
             _indexOptions = v;
         }
 
-        internal virtual void SetPosOutput(IntIndexOutput posOutput) 
+        internal virtual void SetPosOutput(Int32IndexOutput posOutput) 
         {
             _posOutput = posOutput;
             for (var i = 0; i < m_numberOfSkipLevels; i++)
@@ -122,8 +122,8 @@ namespace Lucene.Net.Codecs.Sep
         /// <summary>
         /// Called @ start of new term
         /// </summary>
-        protected internal virtual void ResetSkip(IntIndexOutput.AbstractIndex topDocIndex,
IntIndexOutput.AbstractIndex topFreqIndex,
-            IntIndexOutput.AbstractIndex topPosIndex)
+        protected internal virtual void ResetSkip(Int32IndexOutput.AbstractIndex topDocIndex,
Int32IndexOutput.AbstractIndex topFreqIndex,
+            Int32IndexOutput.AbstractIndex topPosIndex)
         {
             base.ResetSkip();
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
index 7a3fc76..79f1332 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Codecs.IntBlock
         }
 
         // only for testing
-        public IntStreamFactory getIntFactory()
+        public Int32StreamFactory getIntFactory()
         {
             return new MockIntFactory(blockSize);
         }
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs.IntBlock
         /**
          * Encodes blocks as vInts of a fixed block size.
          */
-        public class MockIntFactory : IntStreamFactory
+        public class MockIntFactory : Int32StreamFactory
         {
             private readonly int blockSize;
 
@@ -66,12 +66,12 @@ namespace Lucene.Net.Codecs.IntBlock
                 this.blockSize = blockSize;
             }
 
-            public override IntIndexInput OpenInput(Directory dir, string fileName, IOContext
context)
+            public override Int32IndexInput OpenInput(Directory dir, string fileName, IOContext
context)
             {
                 return new FixedIntBlockIndexInputAnonymousHelper(this, dir.OpenInput(fileName,
context));
             }
 
-            private class FixedIntBlockIndexInputAnonymousHelper : FixedIntBlockIndexInput
+            private class FixedIntBlockIndexInputAnonymousHelper : FixedInt32BlockIndexInput
             {
                 private readonly MockIntFactory outerInstance;
 
@@ -86,7 +86,7 @@ namespace Lucene.Net.Codecs.IntBlock
                     return new BlockReaderAnonymousHelper(outerInstance, @in, buffer);
                 }
 
-                private class BlockReaderAnonymousHelper : FixedIntBlockIndexInput.IBlockReader
+                private class BlockReaderAnonymousHelper : FixedInt32BlockIndexInput.IBlockReader
                 {
                     private readonly MockIntFactory outerInstance;
                     private readonly IndexInput @in;
@@ -113,7 +113,7 @@ namespace Lucene.Net.Codecs.IntBlock
             }
 
 
-            public override IntIndexOutput CreateOutput(Directory dir, string fileName, IOContext
context)
+            public override Int32IndexOutput CreateOutput(Directory dir, string fileName,
IOContext context)
             {
                 IndexOutput output = dir.CreateOutput(fileName, context);
                 bool success = false;
@@ -134,7 +134,7 @@ namespace Lucene.Net.Codecs.IntBlock
             }
         }
 
-        private class FixedIntBlockIndexOutputAnonymousHelper : FixedIntBlockIndexOutput
+        private class FixedIntBlockIndexOutputAnonymousHelper : FixedInt32BlockIndexOutput
         {
             public FixedIntBlockIndexOutputAnonymousHelper(IndexOutput output, int blockSize)
                 : base(output, blockSize)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
index 99878b0..cce4b37 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -55,7 +55,7 @@ namespace Lucene.Net.Codecs.IntBlock
          * If the first value is &lt;= 3, writes baseBlockSize vInts at once,
          * otherwise writes 2*baseBlockSize vInts.
          */
-        public class MockIntFactory : IntStreamFactory
+        public class MockIntFactory : Int32StreamFactory
         {
 
             private readonly int baseBlockSize;
@@ -65,14 +65,14 @@ namespace Lucene.Net.Codecs.IntBlock
                 this.baseBlockSize = baseBlockSize;
             }
 
-            public override IntIndexInput OpenInput(Directory dir, string fileName, IOContext
context)
+            public override Int32IndexInput OpenInput(Directory dir, string fileName, IOContext
context)
             {
                 IndexInput input = dir.OpenInput(fileName, context);
                 int baseBlockSize = input.ReadInt32();
                 return new VariableIntBlockIndexInputAnonymousHelper(input, baseBlockSize);
             }
 
-            private class VariableIntBlockIndexInputAnonymousHelper : VariableIntBlockIndexInput
+            private class VariableIntBlockIndexInputAnonymousHelper : VariableInt32BlockIndexInput
             {
                 private readonly int baseBlockSize;
 
@@ -117,14 +117,14 @@ namespace Lucene.Net.Codecs.IntBlock
                 }
             }
 
-            public override IntIndexOutput CreateOutput(Directory dir, string fileName, IOContext
context)
+            public override Int32IndexOutput CreateOutput(Directory dir, string fileName,
IOContext context)
             {
                 IndexOutput output = dir.CreateOutput(fileName, context);
                 bool success = false;
                 try
                 {
                     output.WriteInt32(baseBlockSize);
-                    VariableIntBlockIndexOutput ret = new VariableIntBlockIndexOutputAnonymousHelper(output,
2 * baseBlockSize);
+                    VariableInt32BlockIndexOutput ret = new VariableIntBlockIndexOutputAnonymousHelper(output,
2 * baseBlockSize);
                     success = true;
                     return ret;
                 }
@@ -138,7 +138,7 @@ namespace Lucene.Net.Codecs.IntBlock
             }
         }
 
-        private class VariableIntBlockIndexOutputAnonymousHelper : VariableIntBlockIndexOutput
+        private class VariableIntBlockIndexOutputAnonymousHelper : VariableInt32BlockIndexOutput
         {
             private readonly int baseBlockSize;
             public VariableIntBlockIndexOutputAnonymousHelper(IndexOutput output, int baseBlockSize)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntFactory.cs b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntFactory.cs
index 853202d..b51b46d 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntFactory.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntFactory.cs
@@ -20,14 +20,14 @@ namespace Lucene.Net.Codecs.MockSep
      * limitations under the License.
      */
 
-    public class MockSingleIntFactory : IntStreamFactory
+    public class MockSingleIntFactory : Int32StreamFactory
     {
-        public override IntIndexInput OpenInput(Directory dir, string fileName, IOContext
context)
+        public override Int32IndexInput OpenInput(Directory dir, string fileName, IOContext
context)
         {
             return new MockSingleIntIndexInput(dir, fileName, context);
         }
 
-        public override IntIndexOutput CreateOutput(Directory dir, string fileName, IOContext
context)
+        public override Int32IndexOutput CreateOutput(Directory dir, string fileName, IOContext
context)
         {
             return new MockSingleIntIndexOutput(dir, fileName, context);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexInput.cs b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexInput.cs
index e949505..a750735 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexInput.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexInput.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Codecs.MockSep
     /// 
     /// @lucene.experimental
     /// </summary>
-    public class MockSingleIntIndexInput : IntIndexInput
+    public class MockSingleIntIndexInput : Int32IndexInput
     {
         private readonly IndexInput @in;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexOutput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexOutput.cs b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexOutput.cs
index 47d6a29..99a067b 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexOutput.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockSep/MockSingleIntIndexOutput.cs
@@ -10,7 +10,7 @@ namespace Lucene.Net.Codecs.MockSep
     /// 
     /// @lucene.experimental
     /// </summary>
-    public class MockSingleIntIndexOutput : IntIndexOutput
+    public class MockSingleIntIndexOutput : Int32IndexOutput
     {
         private readonly IndexOutput @out;
         internal const string CODEC = "SINGLE_INTS";

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d3dfb950/src/Lucene.Net.Tests.Codecs/IntBlock/TestIntBlockCodec.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Codecs/IntBlock/TestIntBlockCodec.cs b/src/Lucene.Net.Tests.Codecs/IntBlock/TestIntBlockCodec.cs
index 7d38c4d..582a684 100644
--- a/src/Lucene.Net.Tests.Codecs/IntBlock/TestIntBlockCodec.cs
+++ b/src/Lucene.Net.Tests.Codecs/IntBlock/TestIntBlockCodec.cs
@@ -30,17 +30,17 @@ namespace Lucene.Net.Codecs.IntBlock
         {
             Directory dir = NewDirectory();
 
-            IntStreamFactory f = (new MockFixedIntBlockPostingsFormat(128)).getIntFactory();
+            Int32StreamFactory f = (new MockFixedIntBlockPostingsFormat(128)).getIntFactory();
 
-            IntIndexOutput @out = f.CreateOutput(dir, "test", NewIOContext(Random()));
+            Int32IndexOutput @out = f.CreateOutput(dir, "test", NewIOContext(Random()));
             for (int i = 0; i < 11777; i++)
             {
                 @out.Write(i);
             }
             @out.Dispose();
 
-            IntIndexInput @in = f.OpenInput(dir, "test", NewIOContext(Random()));
-            IntIndexInput.AbstractReader r = @in.GetReader();
+            Int32IndexInput @in = f.OpenInput(dir, "test", NewIOContext(Random()));
+            Int32IndexInput.AbstractReader r = @in.GetReader();
 
             for (int i = 0; i < 11777; i++)
             {
@@ -56,13 +56,13 @@ namespace Lucene.Net.Codecs.IntBlock
         {
             Directory dir = NewDirectory();
 
-            IntStreamFactory f = (new MockFixedIntBlockPostingsFormat(128)).getIntFactory();
-            IntIndexOutput @out = f.CreateOutput(dir, "test", NewIOContext(Random()));
+            Int32StreamFactory f = (new MockFixedIntBlockPostingsFormat(128)).getIntFactory();
+            Int32IndexOutput @out = f.CreateOutput(dir, "test", NewIOContext(Random()));
 
             // write no ints
             @out.Dispose();
 
-            IntIndexInput @in = f.OpenInput(dir, "test", NewIOContext(Random()));
+            Int32IndexInput @in = f.OpenInput(dir, "test", NewIOContext(Random()));
             @in.GetReader();
             // read no ints
             @in.Dispose();


Mime
View raw message