lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [30/37] lucenenet git commit: Lucene.Net.Codecs: Renamed protected fields camelCase prefixed with m_
Date Sun, 29 Jan 2017 13:27:52 GMT
Lucene.Net.Codecs: Renamed protected fields camelCase prefixed with m_


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/76605096
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/76605096
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/76605096

Branch: refs/heads/api-work
Commit: 76605096154eb6270c6bf51f99a408f17e59799e
Parents: f46d372
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sun Jan 29 17:34:24 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sun Jan 29 17:34:24 2017 +0700

----------------------------------------------------------------------
 .../BlockTerms/BlockTermsWriter.cs              | 64 ++++++++++----------
 .../BlockTerms/FixedGapTermsIndexWriter.cs      | 50 +++++++--------
 .../BlockTerms/VariableGapTermsIndexWriter.cs   | 30 ++++-----
 .../Intblock/FixedIntBlockIndexInput.cs         |  8 +--
 .../Intblock/FixedIntBlockIndexOutput.cs        | 14 ++---
 .../Intblock/VariableIntBlockIndexInput.cs      | 10 +--
 .../Intblock/VariableIntBlockIndexOutput.cs     | 10 +--
 .../MockFixedIntBlockPostingsFormat.cs          |  4 +-
 .../MockVariableIntBlockPostingsFormat.cs       |  2 +-
 9 files changed, 96 insertions(+), 96 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
index d7d94ce..f3b6846 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
@@ -48,7 +48,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         /// <summary>Extension of terms file</summary>
         public const string TERMS_EXTENSION = "tib";
 
-        protected IndexOutput _output;
+        protected IndexOutput m_output;
         private readonly PostingsWriterBase postingsWriter;
         private readonly FieldInfos fieldInfos;
         private FieldInfo currentField;
@@ -87,24 +87,24 @@ namespace Lucene.Net.Codecs.BlockTerms
             var termsFileName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name, state.SegmentSuffix,
                 TERMS_EXTENSION);
             this.termsIndexWriter = termsIndexWriter;
-            _output = state.Directory.CreateOutput(termsFileName, state.Context);
+            m_output = state.Directory.CreateOutput(termsFileName, state.Context);
             var success = false;
 
             try
             {
                 fieldInfos = state.FieldInfos;
-                WriteHeader(_output);
+                WriteHeader(m_output);
                 currentField = null;
                 this.postingsWriter = postingsWriter;
 
-                postingsWriter.Init(_output); // have consumer write its format/header
+                postingsWriter.Init(m_output); // have consumer write its format/header
                 success = true;
             }
             finally
             {
                 if (!success)
                 {
-                    IOUtils.CloseWhileHandlingException(_output);
+                    IOUtils.CloseWhileHandlingException(m_output);
                 }
             }
         }
@@ -119,50 +119,50 @@ namespace Lucene.Net.Codecs.BlockTerms
             Debug.Assert(currentField == null || currentField.Name.CompareTo(field.Name)
< 0);
 
             currentField = field;
-            var fiw = termsIndexWriter.AddField(field, _output.FilePointer);
+            var fiw = termsIndexWriter.AddField(field, m_output.FilePointer);
             return new TermsWriter(this, fiw, field, postingsWriter);
         }
 
         public override void Dispose()
         {
-            if (_output == null) return;
+            if (m_output == null) return;
 
             try
             {
-                var dirStart = _output.FilePointer;
+                var dirStart = m_output.FilePointer;
 
-                _output.WriteVInt(_fields.Count);
+                m_output.WriteVInt(_fields.Count);
 
                 foreach (var field in _fields)
                 {
-                    _output.WriteVInt(field.FieldInfo.Number);
-                    _output.WriteVLong(field.NumTerms);
-                    _output.WriteVLong(field.TermsStartPointer);
+                    m_output.WriteVInt(field.FieldInfo.Number);
+                    m_output.WriteVLong(field.NumTerms);
+                    m_output.WriteVLong(field.TermsStartPointer);
                     if (field.FieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                     {
-                        _output.WriteVLong(field.SumTotalTermFreq);
+                        m_output.WriteVLong(field.SumTotalTermFreq);
                     }
-                    _output.WriteVLong(field.SumDocFreq);
-                    _output.WriteVInt(field.DocCount);
+                    m_output.WriteVLong(field.SumDocFreq);
+                    m_output.WriteVInt(field.DocCount);
                     if (VERSION_CURRENT >= VERSION_META_ARRAY)
                     {
-                        _output.WriteVInt(field.LongsSize);
+                        m_output.WriteVInt(field.LongsSize);
                     }
 
                 }
                 WriteTrailer(dirStart);
-                CodecUtil.WriteFooter(_output);
+                CodecUtil.WriteFooter(m_output);
             }
             finally
             {
-                IOUtils.Close(_output, postingsWriter, termsIndexWriter);
-                _output = null;
+                IOUtils.Close(m_output, postingsWriter, termsIndexWriter);
+                m_output = null;
             }
         }
 
         private void WriteTrailer(long dirStart)
         {
-            _output.WriteLong(dirStart);
+            m_output.WriteLong(dirStart);
         }
 
         private class TermEntry
@@ -204,7 +204,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 {
                     _pendingTerms[i] = new TermEntry();
                 }
-                _termsStartPointer = this.outerInstance._output.FilePointer;
+                _termsStartPointer = this.outerInstance.m_output.FilePointer;
                 _postingsWriter = postingsWriter;
                 _longsSize = postingsWriter.SetField(fieldInfo);
             }
@@ -237,7 +237,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // entire block in between index terms:
                         FlushBlock();
                     }
-                    _fieldIndexWriter.Add(text, stats, outerInstance._output.FilePointer);
+                    _fieldIndexWriter.Add(text, stats, outerInstance.m_output.FilePointer);
                 }
 
                 if (_pendingTerms.Length == _pendingCount)
@@ -271,12 +271,12 @@ namespace Lucene.Net.Codecs.BlockTerms
                 }
 
                 // EOF marker:
-                outerInstance._output.WriteVInt(0);
+                outerInstance.m_output.WriteVInt(0);
 
                 _sumTotalTermFreq = sumTotalTermFreq;
                 _sumDocFreq = sumDocFreq;
                 _docCount = docCount;
-                _fieldIndexWriter.Finish(outerInstance._output.FilePointer);
+                _fieldIndexWriter.Finish(outerInstance.m_output.FilePointer);
 
                 if (_numTerms > 0)
                 {
@@ -329,8 +329,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                             _pendingTerms[termCount].Term));
                 }
 
-                outerInstance._output.WriteVInt(_pendingCount);
-                outerInstance._output.WriteVInt(commonPrefix);
+                outerInstance.m_output.WriteVInt(_pendingCount);
+                outerInstance.m_output.WriteVInt(commonPrefix);
 
                 // 2nd pass: write suffixes, as separate byte[] blob
                 for (var termCount = 0; termCount < _pendingCount; termCount++)
@@ -341,8 +341,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                     _bytesWriter.WriteVInt(suffix);
                     _bytesWriter.WriteBytes(_pendingTerms[termCount].Term.Bytes, commonPrefix,
suffix);
                 }
-                outerInstance._output.WriteVInt((int)_bytesWriter.FilePointer);
-                _bytesWriter.WriteTo(outerInstance._output);
+                outerInstance.m_output.WriteVInt((int)_bytesWriter.FilePointer);
+                _bytesWriter.WriteTo(outerInstance.m_output);
                 _bytesWriter.Reset();
 
                 // 3rd pass: write the freqs as byte[] blob
@@ -360,8 +360,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                         _bytesWriter.WriteVLong(state.TotalTermFreq - state.DocFreq);
                     }
                 }
-                outerInstance._output.WriteVInt((int)_bytesWriter.FilePointer);
-                _bytesWriter.WriteTo(outerInstance._output);
+                outerInstance.m_output.WriteVInt((int)_bytesWriter.FilePointer);
+                _bytesWriter.WriteTo(outerInstance.m_output);
                 _bytesWriter.Reset();
 
                 // 4th pass: write the metadata 
@@ -379,8 +379,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                     _bufferWriter.Reset();
                     absolute = false;
                 }
-                outerInstance._output.WriteVInt((int)_bytesWriter.FilePointer);
-                _bytesWriter.WriteTo(outerInstance._output);
+                outerInstance.m_output.WriteVInt((int)_bytesWriter.FilePointer);
+                _bytesWriter.WriteTo(outerInstance.m_output);
                 _bytesWriter.Reset();
 
                 _lastPrevTerm.CopyBytes(_pendingTerms[_pendingCount - 1].Term);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 038e42c..b202a57 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
@@ -37,7 +37,7 @@ namespace Lucene.Net.Codecs.BlockTerms
     /// </summary>
     public class FixedGapTermsIndexWriter : TermsIndexWriterBase
     {
-        protected IndexOutput Output; // out
+        protected IndexOutput m_output;
 
         /// <summary>Extension of terms index file</summary>
         internal const string TERMS_INDEX_EXTENSION = "tii";
@@ -58,20 +58,20 @@ namespace Lucene.Net.Codecs.BlockTerms
             string indexFileName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name,
state.SegmentSuffix,
                 TERMS_INDEX_EXTENSION);
             _termIndexInterval = state.TermIndexInterval;
-            Output = state.Directory.CreateOutput(indexFileName, state.Context);
+            m_output = state.Directory.CreateOutput(indexFileName, state.Context);
             bool success = false;
             try
             {
                 _fieldInfos = state.FieldInfos;
-                WriteHeader(Output);
-                Output.WriteInt(_termIndexInterval);
+                WriteHeader(m_output);
+                m_output.WriteInt(_termIndexInterval);
                 success = true;
             }
             finally
             {
                 if (!success)
                 {
-                    IOUtils.CloseWhileHandlingException(Output);
+                    IOUtils.CloseWhileHandlingException(m_output);
                 }
             }
         }
@@ -137,7 +137,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 this.outerInstance = outerInstance;
                 this.fieldInfo = fieldInfo;
-                indexStart = outerInstance.Output.FilePointer;
+                indexStart = outerInstance.m_output.FilePointer;
                 termsStart = lastTermsPointer = termsFilePointer;
                 termLengths = new short[0];
                 termsPointerDeltas = new int[0];
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                 // write only the min prefix that shows the diff
                 // against prior term
-                outerInstance.Output.WriteBytes(text.Bytes, text.Offset, indexedTermLength);
+                outerInstance.m_output.WriteBytes(text.Bytes, text.Offset, indexedTermLength);
 
                 if (termLengths.Length == numIndexTerms)
                 {
@@ -191,9 +191,9 @@ namespace Lucene.Net.Codecs.BlockTerms
             public override void Finish(long termsFilePointer)
             {
                 // write primary terms dict offsets
-                packedIndexStart = outerInstance.Output.FilePointer;
+                packedIndexStart = outerInstance.m_output.FilePointer;
 
-                PackedInts.Writer w = PackedInts.GetWriter(outerInstance.Output, numIndexTerms,
+                PackedInts.Writer w = PackedInts.GetWriter(outerInstance.m_output, numIndexTerms,
                     PackedInts.BitsRequired(termsFilePointer),
                     PackedInts.DEFAULT);
 
@@ -206,10 +206,10 @@ namespace Lucene.Net.Codecs.BlockTerms
                 }
                 w.Finish();
 
-                packedOffsetsStart = outerInstance.Output.FilePointer;
+                packedOffsetsStart = outerInstance.m_output.FilePointer;
 
                 // write offsets into the byte[] terms
-                w = PackedInts.GetWriter(outerInstance.Output, 1 + numIndexTerms, PackedInts.BitsRequired(totTermLength),
+                w = PackedInts.GetWriter(outerInstance.m_output, 1 + numIndexTerms, PackedInts.BitsRequired(totTermLength),
                     PackedInts.DEFAULT);
                 upto = 0;
                 for (int i = 0; i < numIndexTerms; i++)
@@ -229,12 +229,12 @@ namespace Lucene.Net.Codecs.BlockTerms
 
         public override void Dispose()
         {
-            if (Output != null)
+            if (m_output != null)
             {
                 bool success = false;
                 try
                 {
-                    long dirStart = Output.FilePointer;
+                    long dirStart = m_output.FilePointer;
                     int fieldCount = _fields.Count;
 
                     int nonNullFieldCount = 0;
@@ -247,42 +247,42 @@ namespace Lucene.Net.Codecs.BlockTerms
                         }
                     }
 
-                    Output.WriteVInt(nonNullFieldCount);
+                    m_output.WriteVInt(nonNullFieldCount);
                     for (int i = 0; i < fieldCount; i++)
                     {
                         SimpleFieldWriter field = _fields[i];
                         if (field.numIndexTerms > 0)
                         {
-                            Output.WriteVInt(field.fieldInfo.Number);
-                            Output.WriteVInt(field.numIndexTerms);
-                            Output.WriteVLong(field.termsStart);
-                            Output.WriteVLong(field.indexStart);
-                            Output.WriteVLong(field.packedIndexStart);
-                            Output.WriteVLong(field.packedOffsetsStart);
+                            m_output.WriteVInt(field.fieldInfo.Number);
+                            m_output.WriteVInt(field.numIndexTerms);
+                            m_output.WriteVLong(field.termsStart);
+                            m_output.WriteVLong(field.indexStart);
+                            m_output.WriteVLong(field.packedIndexStart);
+                            m_output.WriteVLong(field.packedOffsetsStart);
                         }
                     }
                     WriteTrailer(dirStart);
-                    CodecUtil.WriteFooter(Output);
+                    CodecUtil.WriteFooter(m_output);
                     success = true;
                 }
                 finally
                 {
                     if (success)
                     {
-                        IOUtils.Close(Output);
+                        IOUtils.Close(m_output);
                     }
                     else
                     {
-                        IOUtils.CloseWhileHandlingException(Output);
+                        IOUtils.CloseWhileHandlingException(m_output);
                     }
-                    Output = null;
+                    m_output = null;
                 }
             }
         }
 
         private void WriteTrailer(long dirStart)
         {
-            Output.WriteLong(dirStart);
+            m_output.WriteLong(dirStart);
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 2426546..296dc20 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Codecs.BlockTerms
     /// </summary>
     public class VariableGapTermsIndexWriter : TermsIndexWriterBase
     {
-        protected IndexOutput Output; // out
+        protected IndexOutput m_output;
 
         /** Extension of terms index file */
         internal const string TERMS_INDEX_EXTENSION = "tiv";
@@ -177,19 +177,19 @@ namespace Lucene.Net.Codecs.BlockTerms
         {
             string indexFileName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name,
state.SegmentSuffix,
                 TERMS_INDEX_EXTENSION);
-            Output = state.Directory.CreateOutput(indexFileName, state.Context);
+            m_output = state.Directory.CreateOutput(indexFileName, state.Context);
             bool success = false;
 
             try
             {
                 _policy = policy;
-                WriteHeader(Output);
+                WriteHeader(m_output);
                 success = true;
             }
             finally
             {
                 if (!success)
-                    IOUtils.CloseWhileHandlingException(Output);
+                    IOUtils.CloseWhileHandlingException(m_output);
             }
         }
 
@@ -251,7 +251,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 FieldInfo = fieldInfo;
                 PositiveIntOutputs fstOutputs = PositiveIntOutputs.Singleton;
                 _fstBuilder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, fstOutputs);
-                IndexStart = this.outerInstance.Output.FilePointer;
+                IndexStart = this.outerInstance.m_output.FilePointer;
 
                 // Always put empty string in
                 _fstBuilder.Add(new IntsRef(), termsFilePointer);
@@ -299,17 +299,17 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 Fst = _fstBuilder.Finish();
                 if (Fst != null)
-                    Fst.Save(outerInstance.Output);
+                    Fst.Save(outerInstance.m_output);
             }
         }
 
         public override void Dispose()
         {
-            if (Output == null) return;
+            if (m_output == null) return;
 
             try
             {
-                long dirStart = Output.FilePointer;
+                long dirStart = m_output.FilePointer;
                 int fieldCount = _fields.Count;
 
                 int nonNullFieldCount = 0;
@@ -322,29 +322,29 @@ namespace Lucene.Net.Codecs.BlockTerms
                     }
                 }
 
-                Output.WriteVInt(nonNullFieldCount);
+                m_output.WriteVInt(nonNullFieldCount);
                 for (int i = 0; i < fieldCount; i++)
                 {
                     FstFieldWriter field = _fields[i];
                     if (field.Fst != null)
                     {
-                        Output.WriteVInt(field.FieldInfo.Number);
-                        Output.WriteVLong(field.IndexStart);
+                        m_output.WriteVInt(field.FieldInfo.Number);
+                        m_output.WriteVLong(field.IndexStart);
                     }
                 }
                 WriteTrailer(dirStart);
-                CodecUtil.WriteFooter(Output);
+                CodecUtil.WriteFooter(m_output);
             }
             finally
             {
-                Output.Dispose();
-                Output = null;
+                m_output.Dispose();
+                m_output = null;
             }
         }
 
         private void WriteTrailer(long dirStart)
         {
-            Output.WriteLong(dirStart);
+            m_output.WriteLong(dirStart);
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 bf269a2..991b5f0 100644
--- a/src/Lucene.Net.Codecs/Intblock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/Intblock/FixedIntBlockIndexInput.cs
@@ -37,17 +37,17 @@ namespace Lucene.Net.Codecs.IntBlock
     public abstract class FixedIntBlockIndexInput : IntIndexInput
     {
         private readonly IndexInput input;
-        protected readonly int blockSize;
+        protected readonly int m_blockSize;
 
         public FixedIntBlockIndexInput(IndexInput @in)
         {
             input = @in;
-            blockSize = @in.ReadVInt();
+            m_blockSize = @in.ReadVInt();
         }
 
         public override AbstractReader GetReader()
         {
-            var buffer = new int[blockSize];
+            var buffer = new int[m_blockSize];
             var clone = (IndexInput)input.Clone();
             // TODO: can this be simplified?
             return new Reader(clone, buffer, GetBlockReader(clone, buffer));
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.IntBlock
                         fp += indexIn.ReadVLong();
                     }
                 }
-                Debug.Assert(upto < outerInstance.blockSize);
+                Debug.Assert(upto < outerInstance.m_blockSize);
             }
 
             public override void Seek(AbstractReader other)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 1f106b3..544b644 100644
--- a/src/Lucene.Net.Codecs/Intblock/FixedIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/Intblock/FixedIntBlockIndexOutput.cs
@@ -39,17 +39,17 @@ namespace Lucene.Net.Codecs.IntBlock
     /// </summary>
     public abstract class FixedIntBlockIndexOutput : IntIndexOutput
     {
-        protected readonly IndexOutput output; // out
+        protected readonly IndexOutput m_output;
         private readonly int blockSize;
-        protected readonly int[] buffer;
+        protected readonly int[] m_buffer;
         private int upto;
 
         protected FixedIntBlockIndexOutput(IndexOutput output, int fixedBlockSize)
         {
             blockSize = fixedBlockSize;
-            this.output = output;
+            this.m_output = output;
             output.WriteVInt(blockSize);
-            buffer = new int[blockSize];
+            m_buffer = new int[blockSize];
         }
 
         protected abstract void FlushBlock();
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override void Mark()
             {
-                fp = outerInstance.output.FilePointer;
+                fp = outerInstance.m_output.FilePointer;
                 upto = outerInstance.upto;
             }
 
@@ -123,7 +123,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
         public override void Write(int v)
         {
-            buffer[upto++] = v;
+            m_buffer[upto++] = v;
             if (upto == blockSize)
             {
                 FlushBlock();
@@ -144,7 +144,7 @@ namespace Lucene.Net.Codecs.IntBlock
             }
             finally
             {
-                output.Dispose();
+                m_output.Dispose();
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 55e02ba..f6a1557 100644
--- a/src/Lucene.Net.Codecs/Intblock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/Intblock/VariableIntBlockIndexInput.cs
@@ -38,18 +38,18 @@ namespace Lucene.Net.Codecs.IntBlock
     /// </summary>
     public abstract class VariableIntBlockIndexInput : IntIndexInput
     {
-        private readonly IndexInput input; // in
-        protected readonly int maxBlockSize;
+        private readonly IndexInput input;
+        protected readonly int m_maxBlockSize;
 
         protected internal VariableIntBlockIndexInput(IndexInput input)
         {
             this.input = input;
-            maxBlockSize = input.ReadInt();
+            m_maxBlockSize = input.ReadInt();
         }
 
         public override AbstractReader GetReader()
         {
-            var buffer = new int[maxBlockSize];
+            var buffer = new int[m_maxBlockSize];
             var clone = (IndexInput)input.Clone();
             // TODO: can this be simplified?
             return new Reader(clone, buffer, GetBlockReader(clone, buffer));
@@ -196,7 +196,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override string ToString()
             {
-                return "VarIntBlock.Index fp=" + fp + " upto=" + upto + " maxBlock=" + outerInstance.maxBlockSize;
+                return "VarIntBlock.Index fp=" + fp + " upto=" + upto + " maxBlock=" + outerInstance.m_maxBlockSize;
             }
 
             public override void Seek(AbstractReader other)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 415a974..f756777 100644
--- a/src/Lucene.Net.Codecs/Intblock/VariableIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/Intblock/VariableIntBlockIndexOutput.cs
@@ -41,7 +41,7 @@ namespace Lucene.Net.Codecs.IntBlock
     /// </summary>
     public abstract class VariableIntBlockIndexOutput : IntIndexOutput
     {
-        protected readonly IndexOutput output; // out
+        protected readonly IndexOutput m_output;
 
         private int upto;
         private bool hitExcDuringWrite;
@@ -57,8 +57,8 @@ namespace Lucene.Net.Codecs.IntBlock
         /// </summary>
         protected VariableIntBlockIndexOutput(IndexOutput output, int maxBlockSize)
         {
-            this.output = output;
-            this.output.WriteInt(maxBlockSize);
+            this.m_output = output;
+            this.m_output.WriteInt(maxBlockSize);
         }
 
         /// <summary>
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override void Mark()
             {
-                fp = outerInstance.output.FilePointer;
+                fp = outerInstance.m_output.FilePointer;
                 upto = outerInstance.upto;
             }
 
@@ -155,7 +155,7 @@ namespace Lucene.Net.Codecs.IntBlock
             }
             finally
             {
-                output.Dispose();
+                m_output.Dispose();
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 fc15dd0..224a385 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
@@ -142,9 +142,9 @@ namespace Lucene.Net.Codecs.IntBlock
             }
             protected override void FlushBlock()
             {
-                for (int i = 0; i < buffer.Length; i++)
+                for (int i = 0; i < m_buffer.Length; i++)
                 {
-                    output.WriteVInt(buffer[i]);
+                    m_output.WriteVInt(m_buffer[i]);
                 }
             }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/76605096/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 eeba725..ba69c73 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 {
                     for (int i = 0; i < flushAt; i++)
                     {
-                        output.WriteVInt(buffer[i]);
+                        m_output.WriteVInt(buffer[i]);
                     }
                     buffer[0] = buffer[flushAt];
                     pendingCount = 1;


Mime
View raw message