lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnas...@apache.org
Subject [2/2] git commit: Updating Lucene.Net.Codes/Pulsing
Date Sun, 14 Sep 2014 23:28:10 GMT
Updating Lucene.Net.Codes/Pulsing


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

Branch: refs/heads/master
Commit: 6e900565dc22706fd946c01c024ec96ca82f2ed1
Parents: 02f232e
Author: Prescott Nasser <pnasser@apache.org>
Authored: Sun Sep 14 16:27:37 2014 -0700
Committer: Prescott Nasser <pnasser@apache.org>
Committed: Sun Sep 14 16:27:37 2014 -0700

----------------------------------------------------------------------
 .../Pulsing/Pulsing41PostingsFormat.cs          |   2 +-
 .../Pulsing/PulsingPostingsFormat.cs            |  10 +-
 .../Pulsing/PulsingPostingsReader.cs            | 486 +++++++++----------
 .../Pulsing/PulsingPostingsWriter.cs            | 319 ++++++------
 src/Lucene.Net.Core/Codecs/PostingsConsumer.cs  |   2 +-
 5 files changed, 384 insertions(+), 435 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6e900565/src/Lucene.Net.Codecs/Pulsing/Pulsing41PostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Pulsing/Pulsing41PostingsFormat.cs b/src/Lucene.Net.Codecs/Pulsing/Pulsing41PostingsFormat.cs
index f2634f4..458771e 100644
--- a/src/Lucene.Net.Codecs/Pulsing/Pulsing41PostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/Pulsing41PostingsFormat.cs
@@ -17,7 +17,7 @@
 
 namespace Lucene.Net.Codecs.Pulsing
 {
-    using Lucene.Net.Codecs.Lucene41;
+    using Lucene41;
 
     /// <summary>
     /// Concrete pulsing implementation over {@link Lucene41PostingsFormat}.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6e900565/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
index 552ecbc..9ab1706 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
@@ -15,14 +15,12 @@
  * limitations under the License.
  */
 
-
-
 namespace Lucene.Net.Codecs.Pulsing
 {
     using System;
     using System.Diagnostics;
-    using Lucene.Net.Index;
-    using Lucene.Net.Util;
+    using Index;
+    using Util;
 
     /// <summary>
     /// This postings format "inlines" the postings for terms that have
@@ -49,11 +47,11 @@ namespace Lucene.Net.Codecs.Pulsing
         {
         }
 
-        /// <summary>Terms with freq <= freqCutoff are inlined into terms dict.</summary>
+        /// <summary>Terms with freq less than or equal freqCutoff are inlined into terms dict.</summary>
         protected PulsingPostingsFormat(String name, PostingsBaseFormat wrappedPostingsBaseFormat, int freqCutoff,
             int minBlockSize, int maxBlockSize) : base(name)
         {
-            Debug.Debug.Assert((minBlockSize > 1);
+            Debug.Assert(minBlockSize > 1);
 
             _freqCutoff = freqCutoff;
             _minBlockSize = minBlockSize;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6e900565/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
index 9f4599b..75334e6 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
@@ -21,9 +21,9 @@ namespace Lucene.Net.Codecs.Pulsing
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
-    using Lucene.Net.Index;
-    using Lucene.Net.Store;
-    using Lucene.Net.Util;
+    using Index;
+    using Store;
+    using Util;
 
     /// <summary>
     /// Concrete class that reads the current doc/freq/skip postings format 
@@ -39,52 +39,52 @@ namespace Lucene.Net.Codecs.Pulsing
 
         // Fallback reader for non-pulsed terms:
         private readonly PostingsReaderBase _wrappedPostingsReader;
-        private readonly SegmentReadState segmentState;
-        private int maxPositions;
-        private int version;
-        private SortedDictionary<int, int> fields;
+        private readonly SegmentReadState _segmentState;
+        private int _maxPositions;
+        private int _version;
+        private SortedDictionary<int, int> _fields;
 
         public PulsingPostingsReader(SegmentReadState state, PostingsReaderBase wrappedPostingsReader)
         {
-            this._wrappedPostingsReader = wrappedPostingsReader;
-            this.segmentState = state;
+            _wrappedPostingsReader = wrappedPostingsReader;
+            _segmentState = state;
         }
 
         public override void Init(IndexInput termsIn)
         {
-            version = CodecUtil.CheckHeader(termsIn, PulsingPostingsWriter.CODEC,
+            _version = CodecUtil.CheckHeader(termsIn, PulsingPostingsWriter.CODEC,
                 PulsingPostingsWriter.VERSION_START,
                 PulsingPostingsWriter.VERSION_CURRENT);
 
-            maxPositions = termsIn.ReadVInt();
+            _maxPositions = termsIn.ReadVInt();
             _wrappedPostingsReader.Init(termsIn);
 
-            if (_wrappedPostingsReader is PulsingPostingsReader || version < PulsingPostingsWriter.VERSION_META_ARRAY)
+            if (_wrappedPostingsReader is PulsingPostingsReader || _version < PulsingPostingsWriter.VERSION_META_ARRAY)
             {
-                fields = null;
+                _fields = null;
             }
             else
             {
-                fields = new SortedDictionary<int, int>();
-                String summaryFileName = IndexFileNames.SegmentFileName(segmentState.SegmentInfo.Name,
-                    segmentState.SegmentSuffix, PulsingPostingsWriter.SUMMARY_EXTENSION);
+                _fields = new SortedDictionary<int, int>();
+                var summaryFileName = IndexFileNames.SegmentFileName(_segmentState.SegmentInfo.Name,
+                    _segmentState.SegmentSuffix, PulsingPostingsWriter.SUMMARY_EXTENSION);
                 IndexInput input = null;
 
                 try
                 {
                     input =
-                        segmentState.Directory.OpenInput(summaryFileName, segmentState.Context);
+                        _segmentState.Directory.OpenInput(summaryFileName, _segmentState.Context);
                     CodecUtil.CheckHeader(input,
                         PulsingPostingsWriter.CODEC,
-                        version,
+                        _version,
                         PulsingPostingsWriter.VERSION_CURRENT);
 
-                    int numField = input.ReadVInt();
-                    for (int i = 0; i < numField; i++)
+                    var numField = input.ReadVInt();
+                    for (var i = 0; i < numField; i++)
                     {
-                        int fieldNum = input.ReadVInt();
-                        int longsSize = input.ReadVInt();
-                        fields.Add(fieldNum, longsSize);
+                        var fieldNum = input.ReadVInt();
+                        var longsSize = input.ReadVInt();
+                        _fields.Add(fieldNum, longsSize);
                     }
                 }
                 finally
@@ -96,25 +96,24 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override BlockTermState NewTermState()
         {
-            var state = new PulsingTermState {WrappedTermState = _wrappedPostingsReader.NewTermState()};
-            return state;
+            return new PulsingTermState {WrappedTermState = _wrappedPostingsReader.NewTermState()};
         }
 
         public override void DecodeTerm(long[] empty, DataInput input, FieldInfo fieldInfo, BlockTermState _termState,
             bool absolute)
         {
-            PulsingTermState termState = (PulsingTermState) _termState;
+            var termState = (PulsingTermState) _termState;
+
+            Debug.Assert(empty.Length == 0);
 
-            Debug.Debug.Assert((empty.Length == 0);
             termState.Absolute = termState.Absolute || absolute;
             // if we have positions, its total TF, otherwise its computed based on docFreq.
             // TODO Double check this is right..
-            long count = FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS.CompareTo(fieldInfo.IndexOptions) <= 0
+            long count = FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS.CompareTo(fieldInfo.FieldIndexOptions) <= 0
                 ? termState.TotalTermFreq
                 : termState.DocFreq;
-            //System.out.println("  count=" + count + " threshold=" + maxPositions);
-
-            if (count <= maxPositions)
+           
+            if (count <= _maxPositions)
             {
                 // Inlined into terms dict -- just read the byte[] blob in,
                 // but don't decode it now (we only decode when a DocsEnum
@@ -134,12 +133,12 @@ namespace Lucene.Net.Codecs.Pulsing
             }
             else
             {
-                int longsSize = fields == null ? 0 : fields[fieldInfo.Number];
+                var longsSize = _fields == null ? 0 : _fields[fieldInfo.Number];
                 if (termState.Longs == null)
                 {
                     termState.Longs = new long[longsSize];
                 }
-                for (int i = 0; i < longsSize; i++)
+                for (var i = 0; i < longsSize; i++)
                 {
                     termState.Longs[i] = input.ReadVLong();
                 }
@@ -156,7 +155,7 @@ namespace Lucene.Net.Codecs.Pulsing
         public override DocsEnum Docs(FieldInfo field, BlockTermState _termState, Bits liveDocs, DocsEnum reuse,
             int flags)
         {
-            PulsingTermState termState = (PulsingTermState) _termState;
+            var termState = (PulsingTermState) _termState;
             if (termState.PostingsSize != -1)
             {
                 PulsingDocsEnum postings;
@@ -171,7 +170,7 @@ namespace Lucene.Net.Codecs.Pulsing
                 else
                 {
                     // the 'reuse' is actually the wrapped enum
-                    PulsingDocsEnum previous = (PulsingDocsEnum) GetOther(reuse);
+                    var previous = (PulsingDocsEnum) GetOther(reuse);
                     if (previous != null && previous.CanReuse(field))
                     {
                         postings = previous;
@@ -181,26 +180,21 @@ namespace Lucene.Net.Codecs.Pulsing
                         postings = new PulsingDocsEnum(field);
                     }
                 }
+                
                 if (reuse != postings)
-                {
                     SetOther(postings, reuse); // postings.other = reuse
-                }
+                
                 return postings.Reset(liveDocs, termState);
             }
-            else
-            {
-                if (reuse is PulsingDocsEnum)
-                {
-                    DocsEnum wrapped = _wrappedPostingsReader.Docs(field, termState.WrappedTermState, liveDocs,
-                        GetOther(reuse), flags);
-                    SetOther(wrapped, reuse); // wrapped.other = reuse
-                    return wrapped;
-                }
-                else
-                {
-                    return _wrappedPostingsReader.Docs(field, termState.WrappedTermState, liveDocs, reuse, flags);
-                }
-            }
+
+            if (!(reuse is PulsingDocsEnum))
+                return _wrappedPostingsReader.Docs(field, termState.WrappedTermState, liveDocs, reuse, flags);
+
+            var wrapped = _wrappedPostingsReader.Docs(field, termState.WrappedTermState, liveDocs,
+                GetOther(reuse), flags);
+
+            SetOther(wrapped, reuse); // wrapped.other = reuse
+            return wrapped;
         }
 
         public override DocsAndPositionsEnum DocsAndPositions(FieldInfo field, BlockTermState _termState, Bits liveDocs,
@@ -208,7 +202,7 @@ namespace Lucene.Net.Codecs.Pulsing
             int flags)
         {
 
-            PulsingTermState termState = (PulsingTermState) _termState;
+            var termState = (PulsingTermState) _termState;
 
             if (termState.PostingsSize != -1)
             {
@@ -224,7 +218,7 @@ namespace Lucene.Net.Codecs.Pulsing
                 else
                 {
                     // the 'reuse' is actually the wrapped enum
-                    PulsingDocsAndPositionsEnum previous = (PulsingDocsAndPositionsEnum) GetOther(reuse);
+                    var previous = (PulsingDocsAndPositionsEnum) GetOther(reuse);
                     if (previous != null && previous.CanReuse(field))
                     {
                         postings = previous;
@@ -238,25 +232,19 @@ namespace Lucene.Net.Codecs.Pulsing
                 {
                     SetOther(postings, reuse); // postings.other = reuse 
                 }
-                return postings.reset(liveDocs, termState);
-            }
-            else
-            {
-                if (reuse is PulsingDocsAndPositionsEnum)
-                {
-                    DocsAndPositionsEnum wrapped = _wrappedPostingsReader.DocsAndPositions(field,
-                        termState.WrappedTermState,
-                        liveDocs, (DocsAndPositionsEnum) GetOther(reuse),
-                        flags);
-                    SetOther(wrapped, reuse); // wrapped.other = reuse
-                    return wrapped;
-                }
-                else
-                {
-                    return _wrappedPostingsReader.DocsAndPositions(field, termState.WrappedTermState, liveDocs, reuse,
-                        flags);
-                }
+                return postings.Reset(liveDocs, termState);
             }
+
+            if (!(reuse is PulsingDocsAndPositionsEnum))
+                return _wrappedPostingsReader.DocsAndPositions(field, termState.WrappedTermState, liveDocs, reuse,
+                    flags);
+
+            var wrapped = _wrappedPostingsReader.DocsAndPositions(field,
+                termState.WrappedTermState,
+                liveDocs, (DocsAndPositionsEnum) GetOther(reuse),
+                flags);
+            SetOther(wrapped, reuse); // wrapped.other = reuse
+            return wrapped;
         }
 
         public override long RamBytesUsed()
@@ -287,14 +275,10 @@ namespace Lucene.Net.Codecs.Pulsing
         private DocsEnum GetOther(DocsEnum de)
         {
             if (de == null)
-            {
                 return null;
-            }
-            else
-            {
-                AttributeSource atts = de.Attributes();
-                return atts.AddAttribute(PulsingEnumAttribute.Enums().get(this);
-            }
+            
+            var atts = de.Attributes();
+            return atts.AddAttribute(PulsingEnumAttribute.class).Enums().get(this);
         }
 
         /// <summary>
@@ -303,8 +287,8 @@ namespace Lucene.Net.Codecs.Pulsing
         /// </summary>
         private DocsEnum SetOther(DocsEnum de, DocsEnum other)
         {
-            AttributeSource atts = de.Attributes();
-            return atts.AddAttribute(PulsingEnumAttributeImpl.Enums().put(this, other));
+            var atts = de.Attributes();
+            return atts.AddAttribute(PulsingEnumAttribute.class).Enums().put(this, other);
         }
 
         ///<summary>
@@ -329,7 +313,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public override object Clone()
             {
-                PulsingTermState clone = (PulsingTermState) base.Clone();
+                var clone = (PulsingTermState) base.Clone();
                 if (PostingsSize != -1)
                 {
                     clone.Postings = new byte[PostingsSize];
@@ -337,14 +321,14 @@ namespace Lucene.Net.Codecs.Pulsing
                 }
                 else
                 {
-                    Debug.Debug.Assert((WrappedTermState != null);
+                    Debug.Assert(WrappedTermState != null);
                     clone.WrappedTermState = (BlockTermState) WrappedTermState.Clone();
                     clone.Absolute = Absolute;
-                    if (Longs != null)
-                    {
-                        clone.Longs = new long[Longs.Length];
-                        Array.Copy(Longs, 0, clone.Longs, 0, Longs.Length);
-                    }
+                    
+                    if (Longs == null) return clone;
+
+                    clone.Longs = new long[Longs.Length];
+                    Array.Copy(Longs, 0, clone.Longs, 0, Longs.Length);
                 }
                 return clone;
             }
@@ -360,7 +344,7 @@ namespace Lucene.Net.Codecs.Pulsing
                     {
                         Postings = new byte[ArrayUtil.Oversize(_other.PostingsSize, 1)];
                     }
-                    System.Array.Copy(_other.Postings, 0, Postings, 0, _other.PostingsSize);
+                    Array.Copy(_other.Postings, 0, Postings, 0, _other.PostingsSize);
                 }
                 else
                 {
@@ -371,373 +355,341 @@ namespace Lucene.Net.Codecs.Pulsing
             public override String ToString()
             {
                 if (PostingsSize == -1)
-                {
                     return "PulsingTermState: not inlined: wrapped=" + WrappedTermState;
-                }
-                else
-                {
-                    return "PulsingTermState: inlined size=" + PostingsSize + " " + base.ToString();
-                }
+                
+                return "PulsingTermState: inlined size=" + PostingsSize + " " + base.ToString();
             }
         }
 
         internal class PulsingDocsEnum : DocsEnum
         {
-            private byte[] postingsBytes;
-            private readonly ByteArrayDataInput postings = new ByteArrayDataInput();
-            private readonly FieldInfo.IndexOptions_e? indexOptions;
-            private readonly bool storePayloads;
-            private readonly bool storeOffsets;
-            private Bits liveDocs;
-
-            private int docID = -1;
-            private int accum;
-            private int freq;
-            private int payloadLength;
-            private int cost;
+            private byte[] _postingsBytes;
+            private readonly ByteArrayDataInput _postings = new ByteArrayDataInput();
+            private readonly FieldInfo.IndexOptions? _indexOptions;
+            private readonly bool _storePayloads;
+            private readonly bool _storeOffsets;
+            private Bits _liveDocs;
+
+            private int _docId = -1;
+            private int _accum;
+            private int _freq;
+            private int _payloadLength;
+            private int _cost;
 
             public PulsingDocsEnum(FieldInfo fieldInfo)
             {
-                indexOptions = fieldInfo.IndexOptions;
-                storePayloads = fieldInfo.HasPayloads();
-                storeOffsets = indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
+                _indexOptions = fieldInfo.FieldIndexOptions;
+                _storePayloads = fieldInfo.HasPayloads();
+                _storeOffsets = _indexOptions.Value.CompareTo(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
             }
 
             public PulsingDocsEnum Reset(Bits liveDocs, PulsingTermState termState)
             {
-                Debug.Debug.Assert((termState.PostingsSize != -1);
+                Debug.Assert(termState.PostingsSize != -1);
 
                 // Must make a copy of termState's byte[] so that if
                 // app does TermsEnum.next(), this DocsEnum is not affected
-                if (postingsBytes == null)
+                if (_postingsBytes == null)
                 {
-                    postingsBytes = new byte[termState.PostingsSize];
+                    _postingsBytes = new byte[termState.PostingsSize];
                 }
-                else if (postingsBytes.Length < termState.PostingsSize)
+                else if (_postingsBytes.Length < termState.PostingsSize)
                 {
-                    postingsBytes = ArrayUtil.Grow(postingsBytes, termState.PostingsSize);
+                    _postingsBytes = ArrayUtil.Grow(_postingsBytes, termState.PostingsSize);
                 }
-                System.Array.Copy(termState.Postings, 0, postingsBytes, 0, termState.PostingsSize);
-                postings.Reset(postingsBytes, 0, termState.PostingsSize);
-                docID = -1;
-                accum = 0;
-                freq = 1;
-                cost = termState.DocFreq;
-                payloadLength = 0;
-                this.liveDocs = liveDocs;
+                System.Array.Copy(termState.Postings, 0, _postingsBytes, 0, termState.PostingsSize);
+                _postings.Reset(_postingsBytes, 0, termState.PostingsSize);
+                _docId = -1;
+                _accum = 0;
+                _freq = 1;
+                _cost = termState.DocFreq;
+                _payloadLength = 0;
+                this._liveDocs = liveDocs;
                 return this;
             }
 
             public bool CanReuse(FieldInfo fieldInfo)
             {
-                return indexOptions == fieldInfo.IndexOptions && storePayloads == fieldInfo.HasPayloads();
+                return _indexOptions == fieldInfo.FieldIndexOptions && _storePayloads == fieldInfo.HasPayloads();
             }
 
             public override int DocID()
             {
-                return docID;
+                return _docId;
             }
 
             public override int NextDoc()
             {
-                //System.out.println("PR nextDoc this= "+ this);
                 while (true)
                 {
-                    if (postings.Eof())
+                    if (_postings.Eof())
+                        return _docId = NO_MORE_DOCS;
+                    
+                    var code = _postings.ReadVInt();
+                    if (_indexOptions == FieldInfo.IndexOptions.DOCS_ONLY)
                     {
-                        return docID = NO_MORE_DOCS;
-                    }
-
-                    int code = postings.ReadVInt();
-                    if (indexOptions == FieldInfo.IndexOptions_e.DOCS_ONLY)
-                    {
-                        accum += code;
+                        _accum += code;
                     }
                     else
                     {
-                        accum += (int)((uint)code >> 1); ; // shift off low bit
-                        if ((code & 1) != 0)
-                        {
-                            // if low bit is set
-                            freq = 1; // freq is one
-                        }
-                        else
-                        {
-                            freq = postings.ReadVInt(); // else read freq
-                        }
+                        _accum += (int)((uint)code >> 1); ; // shift off low bit
+                        _freq = (code & 1) != 0 ? 1 : _postings.ReadVInt();
 
-                        if (indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
+                        if (_indexOptions.Value.CompareTo(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
                         {
                             // Skip positions
-                            if (storePayloads)
+                            if (_storePayloads)
                             {
-                                for (int pos = 0; pos < freq; pos++)
+                                for (var pos = 0; pos < _freq; pos++)
                                 {
-                                    int posCode = postings.ReadVInt();
+                                    var posCode = _postings.ReadVInt();
                                     if ((posCode & 1) != 0)
                                     {
-                                        payloadLength = postings.ReadVInt();
+                                        _payloadLength = _postings.ReadVInt();
                                     }
-                                    if (storeOffsets && (postings.ReadVInt() & 1) != 0)
+                                    if (_storeOffsets && (_postings.ReadVInt() & 1) != 0)
                                     {
                                         // new offset length
-                                        postings.ReadVInt();
+                                        _postings.ReadVInt();
                                     }
-                                    if (payloadLength != 0)
+                                    if (_payloadLength != 0)
                                     {
-                                        postings.SkipBytes(payloadLength);
+                                        _postings.SkipBytes(_payloadLength);
                                     }
                                 }
                             }
                             else
                             {
-                                for (int pos = 0; pos < freq; pos++)
+                                for (var pos = 0; pos < _freq; pos++)
                                 {
                                     // TODO: skipVInt
-                                    postings.ReadVInt();
-                                    if (storeOffsets && (postings.ReadVInt() & 1) != 0)
+                                    _postings.ReadVInt();
+                                    if (_storeOffsets && (_postings.ReadVInt() & 1) != 0)
                                     {
                                         // new offset length
-                                        postings.ReadVInt();
+                                        _postings.ReadVInt();
                                     }
                                 }
                             }
                         }
                     }
 
-                    if (liveDocs == null || liveDocs.Get(accum))
-                    {
-                        return (docID = accum);
-                    }
-
+                    if (_liveDocs == null || _liveDocs.Get(_accum))
+                        return (_docId = _accum);
                 }
             }
 
             public override int Advance(int target)
             {
-                return docID = SlowAdvance(target);
+                return _docId = SlowAdvance(target);
             }
 
             public override long Cost()
             {
-                return cost;
+                return _cost;
             }
 
             public override int Freq()
             {
-                return freq;
+                return _freq;
             }
         }
 
         internal class PulsingDocsAndPositionsEnum : DocsAndPositionsEnum
         {
-            private byte[] postingsBytes;
-            private readonly ByteArrayDataInput postings = new ByteArrayDataInput();
-            private readonly bool storePayloads;
-            private readonly bool storeOffsets;
+            private byte[] _postingsBytes;
+            private readonly ByteArrayDataInput _postings = new ByteArrayDataInput();
+            private readonly bool _storePayloads;
+            private readonly bool _storeOffsets;
             // note: we could actually reuse across different options, if we passed this to reset()
             // and re-init'ed storeOffsets accordingly (made it non-final)
-            private readonly FieldInfo.IndexOptions_e? indexOptions;
-
-            private Bits liveDocs;
-            private int docID = -1;
-            private int accum;
-            private int freq;
-            private int posPending;
-            private int position;
-            private int payloadLength;
-            private BytesRef payload;
-            private int startOffset;
-            private int offsetLength;
-
-            private bool payloadRetrieved;
-            private int cost;
+            private readonly FieldInfo.IndexOptions? _indexOptions;
+
+            private Bits _liveDocs;
+            private int _docId = -1;
+            private int _accum;
+            private int _freq;
+            private int _posPending;
+            private int _position;
+            private int _payloadLength;
+            private BytesRef _payload;
+            private int _startOffset;
+            private int _offsetLength;
+
+            private bool _payloadRetrieved;
+            private int _cost;
 
             public PulsingDocsAndPositionsEnum(FieldInfo fieldInfo)
             {
-                indexOptions = fieldInfo.IndexOptions;
-                storePayloads = fieldInfo.HasPayloads();
-                storeOffsets =
-                    indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
+                _indexOptions = fieldInfo.FieldIndexOptions;
+                _storePayloads = fieldInfo.HasPayloads();
+                _storeOffsets =
+                    _indexOptions.Value.CompareTo(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
             }
 
-            public PulsingDocsAndPositionsEnum reset(Bits liveDocs, PulsingTermState termState)
+            public PulsingDocsAndPositionsEnum Reset(Bits liveDocs, PulsingTermState termState)
             {
-                Debug.Debug.Assert((termState.PostingsSize != -1);
+                Debug.Assert(termState.PostingsSize != -1);
 
-                if (postingsBytes == null)
+                if (_postingsBytes == null)
                 {
-                    postingsBytes = new byte[termState.PostingsSize];
+                    _postingsBytes = new byte[termState.PostingsSize];
                 }
-                else if (postingsBytes.Length < termState.PostingsSize)
+                else if (_postingsBytes.Length < termState.PostingsSize)
                 {
-                    postingsBytes = ArrayUtil.Grow(postingsBytes, termState.PostingsSize);
+                    _postingsBytes = ArrayUtil.Grow(_postingsBytes, termState.PostingsSize);
                 }
 
-                System.Array.Copy(termState.Postings, 0, postingsBytes, 0, termState.PostingsSize);
-                postings.Reset(postingsBytes, 0, termState.PostingsSize);
-                this.liveDocs = liveDocs;
-                payloadLength = 0;
-                posPending = 0;
-                docID = -1;
-                accum = 0;
-                cost = termState.DocFreq;
-                startOffset = storeOffsets ? 0 : -1; // always return -1 if no offsets are stored
-                offsetLength = 0;
+                Array.Copy(termState.Postings, 0, _postingsBytes, 0, termState.PostingsSize);
+                _postings.Reset(_postingsBytes, 0, termState.PostingsSize);
+                this._liveDocs = liveDocs;
+                _payloadLength = 0;
+                _posPending = 0;
+                _docId = -1;
+                _accum = 0;
+                _cost = termState.DocFreq;
+                _startOffset = _storeOffsets ? 0 : -1; // always return -1 if no offsets are stored
+                _offsetLength = 0;
                 //System.out.println("PR d&p reset storesPayloads=" + storePayloads + " bytes=" + bytes.length + " this=" + this);
                 return this;
             }
 
             public bool CanReuse(FieldInfo fieldInfo)
             {
-                return indexOptions == fieldInfo.IndexOptions && storePayloads == fieldInfo.HasPayloads();
+                return _indexOptions == fieldInfo.FieldIndexOptions && _storePayloads == fieldInfo.HasPayloads();
             }
 
             public override int NextDoc()
             {
-
                 while (true)
                 {
-
                     SkipPositions();
 
-                    if (postings.Eof())
+                    if (_postings.Eof())
                     {
-                        return docID = NO_MORE_DOCS;
+                        return _docId = NO_MORE_DOCS;
                     }
 
-                    int code = postings.ReadVInt();
-                    accum += (int)((uint)code >> 1); // shift off low bit 
-                    if ((code & 1) != 0)
-                    {
-                        // if low bit is set
-                        freq = 1; // freq is one
-                    }
-                    else
-                    {
-                        freq = postings.ReadVInt(); // else read freq
-                    }
-                    posPending = freq;
-                    startOffset = storeOffsets ? 0 : -1; // always return -1 if no offsets are stored
+                    var code = _postings.ReadVInt();
+                    _accum += (int)((uint)code >> 1); // shift off low bit 
+                    _freq = (code & 1) != 0 ? 1 : _postings.ReadVInt();
+                    _posPending = _freq;
+                    _startOffset = _storeOffsets ? 0 : -1; // always return -1 if no offsets are stored
 
-                    if (liveDocs == null || liveDocs.Get(accum))
-                    {
-                        position = 0;
-                        return (docID = accum);
-                    }
+                    if (_liveDocs != null && !_liveDocs.Get(_accum)) continue;
+
+                    _position = 0;
+                    return (_docId = _accum);
                 }
             }
 
             public override int Freq()
             {
-                return freq;
+                return _freq;
             }
 
             public override int DocID()
             {
-                return docID;
+                return _docId;
             }
 
             public override int Advance(int target)
             {
-                return docID = SlowAdvance(target);
+                return _docId = SlowAdvance(target);
             }
 
             public override int NextPosition()
             {
-                Debug.Debug.Assert((posPending > 0);
+                Debug.Assert(_posPending > 0);
 
-                posPending--;
+                _posPending--;
 
-                if (storePayloads)
+                if (_storePayloads)
                 {
-                    if (!payloadRetrieved)
+                    if (!_payloadRetrieved)
                     {
-                        postings.SkipBytes(payloadLength);
+                        _postings.SkipBytes(_payloadLength);
                     }
-                    int code = postings.ReadVInt();
+                    int code = _postings.ReadVInt();
                     if ((code & 1) != 0)
                     {
-                        payloadLength = postings.ReadVInt();
+                        _payloadLength = _postings.ReadVInt();
                     }
-                    position += (int)((uint)code >> 1);
-                    payloadRetrieved = false;
+                    _position += (int)((uint)code >> 1);
+                    _payloadRetrieved = false;
                 }
                 else
                 {
-                    position += postings.ReadVInt();
+                    _position += _postings.ReadVInt();
                 }
 
-                if (storeOffsets)
+                if (_storeOffsets)
                 {
-                    int offsetCode = postings.ReadVInt();
+                    int offsetCode = _postings.ReadVInt();
                     if ((offsetCode & 1) != 0)
                     {
                         // new offset length
-                        offsetLength = postings.ReadVInt();
+                        _offsetLength = _postings.ReadVInt();
                     }
-                    startOffset += (int)((uint)offsetCode >> 1);
+                    _startOffset += (int)((uint)offsetCode >> 1);
                 }
 
-                return position;
+                return _position;
             }
 
             public override int StartOffset()
             {
-                return startOffset;
+                return _startOffset;
             }
 
             public override int EndOffset()
             {
-                return startOffset + offsetLength;
+                return _startOffset + _offsetLength;
             }
 
             public override BytesRef Payload
             {
                 get
                 {
-                    if (payloadRetrieved)
-                    {
-                        return payload;
-                    }
-                    else if (storePayloads && payloadLength > 0)
+                    if (_payloadRetrieved)
+                        return _payload;
+                    
+                    if (_storePayloads && _payloadLength > 0)
                     {
-                        payloadRetrieved = true;
-                        if (payload == null)
+                        _payloadRetrieved = true;
+                        if (_payload == null)
                         {
-                            payload = new BytesRef(payloadLength);
+                            _payload = new BytesRef(_payloadLength);
                         }
                         else
                         {
-                            payload.Grow(payloadLength);
+                            _payload.Grow(_payloadLength);
                         }
-                        postings.ReadBytes(payload.Bytes, 0, payloadLength);
-                        payload.Length = payloadLength;
-                        return payload;
-                    }
-                    else
-                    {
-                        return null;
+                        _postings.ReadBytes(_payload.Bytes, 0, _payloadLength);
+                        _payload.Length = _payloadLength;
+                        return _payload;
                     }
+                    
+                    return null;
                 }
             }
 
             private void SkipPositions()
             {
-                while (posPending != 0)
+                while (_posPending != 0)
                 {
                     NextPosition();
                 }
-                if (storePayloads && !payloadRetrieved)
+                if (_storePayloads && !_payloadRetrieved)
                 {
-                    postings.SkipBytes(payloadLength);
-                    payloadRetrieved = true;
+                    _postings.SkipBytes(_payloadLength);
+                    _payloadRetrieved = true;
                 }
             }
             
             public override long Cost()
             {
-                return cost;
+                return _cost;
             }
         }
         

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6e900565/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
index 528f8de..82fe52a 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
@@ -15,15 +15,14 @@
  * limitations under the License.
  */
 
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using Lucene.Net.Index;
-using Lucene.Net.Store;
-using Lucene.Net.Util;
-
 namespace Lucene.Net.Codecs.Pulsing
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using Index;
+    using Store;
+    using Util;
 
     /// <summary>
     /// TODO: we now inline based on total TF of the term,
@@ -53,36 +52,36 @@ namespace Lucene.Net.Codecs.Pulsing
         internal static readonly int VERSION_META_ARRAY = 1;
         internal static readonly int VERSION_CURRENT = VERSION_META_ARRAY;
 
-        private SegmentWriteState segmentState;
-        private IndexOutput termsOut;
-        private List<FieldMetaData> fields;
-        private FieldInfo.IndexOptions_e? indexOptions;
-        private bool storePayloads;
+        private readonly SegmentWriteState _segmentState;
+        private IndexOutput _termsOut;
+        private readonly List<FieldMetaData> _fields;
+        private FieldInfo.IndexOptions? _indexOptions;
+        private bool _storePayloads;
 
         // information for wrapped PF, in current field
-        private int longsSize;
-        private long[] longs;
-        private bool absolute;
+        private int _longsSize;
+        private long[] _longs;
+        private bool _absolute;
 
         private class PulsingTermState : BlockTermState
         {
-            internal byte[] bytes;
-            internal BlockTermState wrappedState;
+            internal byte[] BYTES;
+            internal BlockTermState WRAPPED_STATE;
 
             public override String ToString()
             {
-                if (bytes != null)
+                if (BYTES != null)
                 {
                     return "inlined";
                 }
-                return "not inlined wrapped=" + wrappedState;
+                return "not inlined wrapped=" + WRAPPED_STATE;
             }
         }
 
         // one entry per position
-        private Position[] pending;
-        private int pendingCount = 0;   // -1 once we've hit too many positions
-        private Position currentDoc;    // first Position entry of current doc
+        private readonly Position[] _pending;
+        private int _pendingCount = 0;   // -1 once we've hit too many positions
+        private Position _currentDoc;    // first Position entry of current doc
 
         private sealed class Position
         {
@@ -114,43 +113,42 @@ namespace Lucene.Net.Codecs.Pulsing
 
         /// <summary>
         /// If the total number of positions (summed across all docs
-        /// for this term) is <= maxPositions, then the postings are
+        /// for this term) is less than or equal maxPositions, then the postings are
         /// inlined into terms dict
         /// </summary>
         public PulsingPostingsWriter(SegmentWriteState state, int maxPositions, PostingsWriterBase wrappedPostingsWriter)
         {
 
-            pending = new Position[maxPositions];
-            for (int i = 0; i < maxPositions; i++)
+            _pending = new Position[maxPositions];
+            for (var i = 0; i < maxPositions; i++)
             {
-                pending[i] = new Position();
+                _pending[i] = new Position();
             }
-            fields = new List<FieldMetaData>();
+            _fields = new List<FieldMetaData>();
 
             // We simply wrap another postings writer, but only call
             // on it when tot positions is >= the cutoff:
-            this._wrappedPostingsWriter = wrappedPostingsWriter;
-            this.segmentState = state;
+            _wrappedPostingsWriter = wrappedPostingsWriter;
+            _segmentState = state;
         }
 
         public override void Init(IndexOutput termsOut)
         {
-            this.termsOut = termsOut;
+            _termsOut = termsOut;
             CodecUtil.WriteHeader(termsOut, CODEC, VERSION_CURRENT);
-            termsOut.WriteVInt(pending.Length); // encode maxPositions in header
+            termsOut.WriteVInt(_pending.Length); // encode maxPositions in header
             _wrappedPostingsWriter.Init(termsOut);
         }
 
         public override BlockTermState NewTermState()
         {
-            PulsingTermState state = new PulsingTermState();
-            state.wrappedState = _wrappedPostingsWriter.NewTermState();
+            var state = new PulsingTermState {WRAPPED_STATE = _wrappedPostingsWriter.NewTermState()};
             return state;
         }
 
         public override void StartTerm()
         {
-            Debug.Debug.Assert((pendingCount == 0);
+            Debug.Assert(_pendingCount == 0);
         }
 
         /// <summary>
@@ -163,61 +161,61 @@ namespace Lucene.Net.Codecs.Pulsing
         /// <returns></returns>
         public override int SetField(FieldInfo fieldInfo)
         {
-            this.indexOptions = fieldInfo.IndexOptions;
-            storePayloads = fieldInfo.HasPayloads();
-            absolute = false;
-            longsSize = _wrappedPostingsWriter.SetField(fieldInfo);
-            longs = new long[longsSize];
-            fields.Add(new FieldMetaData(fieldInfo.Number, longsSize));
+            _indexOptions = fieldInfo.FieldIndexOptions;
+            _storePayloads = fieldInfo.HasPayloads();
+            _absolute = false;
+            _longsSize = _wrappedPostingsWriter.SetField(fieldInfo);
+            _longs = new long[_longsSize];
+            _fields.Add(new FieldMetaData(fieldInfo.Number, _longsSize));
             return 0;
         }
 
-        public override void StartDoc(int docID, int termDocFreq)
+        public override void StartDoc(int docId, int termDocFreq)
         {
-            Debug.Debug.Assert((docID >= 0, "Got DocID=" + docID);
+            Debug.Assert(docId >= 0, "Got DocID=" + docId);
 
-            if (pendingCount == pending.Length)
+            if (_pendingCount == _pending.Length)
             {
-                push();
+                Push();
                 _wrappedPostingsWriter.FinishDoc();
             }
 
-            if (pendingCount != -1)
+            if (_pendingCount != -1)
             {
-                Debug.Debug.Assert((pendingCount < pending.Length);
-                currentDoc = pending[pendingCount];
-                currentDoc.docID = docID;
-                if (indexOptions == FieldInfo.IndexOptions_e.DOCS_ONLY)
+                Debug.Assert(_pendingCount < _pending.Length);
+                _currentDoc = _pending[_pendingCount];
+                _currentDoc.docID = docId;
+                if (_indexOptions == FieldInfo.IndexOptions.DOCS_ONLY)
                 {
-                    pendingCount++;
+                    _pendingCount++;
                 }
-                else if (indexOptions == FieldInfo.IndexOptions_e.DOCS_AND_FREQS)
+                else if (_indexOptions == FieldInfo.IndexOptions.DOCS_AND_FREQS)
                 {
-                    pendingCount++;
-                    currentDoc.termFreq = termDocFreq;
+                    _pendingCount++;
+                    _currentDoc.termFreq = termDocFreq;
                 }
                 else
                 {
-                    currentDoc.termFreq = termDocFreq;
+                    _currentDoc.termFreq = termDocFreq;
                 }
             }
             else
             {
                 // We've already seen too many docs for this term --
                 // just forward to our fallback writer
-                _wrappedPostingsWriter.StartDoc(docID, termDocFreq);
+                _wrappedPostingsWriter.StartDoc(docId, termDocFreq);
             }
         }
 
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
 
-            if (pendingCount == pending.Length)
+            if (_pendingCount == _pending.Length)
             {
-                push();
+                Push();
             }
 
-            if (pendingCount == -1)
+            if (_pendingCount == -1)
             {
                 // We've already seen too many docs for this term --
                 // just forward to our fallback writer
@@ -226,11 +224,11 @@ namespace Lucene.Net.Codecs.Pulsing
             else
             {
                 // buffer up
-                Position pos = pending[pendingCount++];
+                Position pos = _pending[_pendingCount++];
                 pos.pos = position;
                 pos.startOffset = startOffset;
                 pos.endOffset = endOffset;
-                pos.docID = currentDoc.docID;
+                pos.docID = _currentDoc.docID;
                 if (payload != null && payload.Length > 0)
                 {
                     if (pos.payload == null)
@@ -251,13 +249,13 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void FinishDoc()
         {
-            if (pendingCount == -1)
+            if (_pendingCount == -1)
             {
                 _wrappedPostingsWriter.FinishDoc();
             }
         }
 
-        private readonly RAMOutputStream buffer = new RAMOutputStream();
+        private readonly RAMOutputStream _buffer = new RAMOutputStream();
 
         /// <summary>
         /// Called when we are done adding docs to this term
@@ -265,16 +263,16 @@ namespace Lucene.Net.Codecs.Pulsing
         /// <param name="_state"></param>
         public override void FinishTerm(BlockTermState _state)
         {
-            PulsingTermState state = (PulsingTermState) _state;
+            var state = (PulsingTermState) _state;
 
-            Debug.Debug.Assert((pendingCount > 0 || pendingCount == -1);
+            Debug.Assert(_pendingCount > 0 || _pendingCount == -1);
 
-            if (pendingCount == -1)
+            if (_pendingCount == -1)
             {
-                state.wrappedState.DocFreq = state.DocFreq;
-                state.wrappedState.TotalTermFreq = state.TotalTermFreq;
-                state.bytes = null;
-                _wrappedPostingsWriter.FinishTerm(state.wrappedState);
+                state.WRAPPED_STATE.DocFreq = state.DocFreq;
+                state.WRAPPED_STATE.TotalTermFreq = state.TotalTermFreq;
+                state.BYTES = null;
+                _wrappedPostingsWriter.FinishTerm(state.WRAPPED_STATE);
             }
             else
             {
@@ -288,72 +286,72 @@ namespace Lucene.Net.Codecs.Pulsing
                 // given codec wants to store other interesting
                 // stuff, it could use this pulsing codec to do so
 
-                if (indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
+                if (_indexOptions >= FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
                 {
-                    int lastDocID = 0;
-                    int pendingIDX = 0;
-                    int lastPayloadLength = -1;
-                    int lastOffsetLength = -1;
-                    while (pendingIDX < pendingCount)
+                    var lastDocID = 0;
+                    var pendingIDX = 0;
+                    var lastPayloadLength = -1;
+                    var lastOffsetLength = -1;
+                    while (pendingIDX < _pendingCount)
                     {
-                        Position doc = pending[pendingIDX];
+                        var doc = _pending[pendingIDX];
 
-                        int delta = doc.docID - lastDocID;
+                        var delta = doc.docID - lastDocID;
                         lastDocID = doc.docID;
 
                         // if (DEBUG) System.out.println("  write doc=" + doc.docID + " freq=" + doc.termFreq);
 
                         if (doc.termFreq == 1)
                         {
-                            buffer.WriteVInt((delta << 1) | 1);
+                            _buffer.WriteVInt((delta << 1) | 1);
                         }
                         else
                         {
-                            buffer.WriteVInt(delta << 1);
-                            buffer.WriteVInt(doc.termFreq);
+                            _buffer.WriteVInt(delta << 1);
+                            _buffer.WriteVInt(doc.termFreq);
                         }
 
-                        int lastPos = 0;
-                        int lastOffset = 0;
-                        for (int posIDX = 0; posIDX < doc.termFreq; posIDX++)
+                        var lastPos = 0;
+                        var lastOffset = 0;
+                        for (var posIDX = 0; posIDX < doc.termFreq; posIDX++)
                         {
-                            Position pos = pending[pendingIDX++];
-                            Debug.Debug.Assert((pos.docID == doc.docID);
-                            int posDelta = pos.pos - lastPos;
+                            var pos = _pending[pendingIDX++];
+                            Debug.Assert(pos.docID == doc.docID);
+                            var posDelta = pos.pos - lastPos;
                             lastPos = pos.pos;
                             
-                            int payloadLength = pos.payload == null ? 0 : pos.payload.Length;
-                            if (storePayloads)
+                            var payloadLength = pos.payload == null ? 0 : pos.payload.Length;
+                            if (_storePayloads)
                             {
                                 if (payloadLength != lastPayloadLength)
                                 {
-                                    buffer.WriteVInt((posDelta << 1) | 1);
-                                    buffer.WriteVInt(payloadLength);
+                                    _buffer.WriteVInt((posDelta << 1) | 1);
+                                    _buffer.WriteVInt(payloadLength);
                                     lastPayloadLength = payloadLength;
                                 }
                                 else
                                 {
-                                    buffer.WriteVInt(posDelta << 1);
+                                    _buffer.WriteVInt(posDelta << 1);
                                 }
                             }
                             else
                             {
-                                buffer.WriteVInt(posDelta);
+                                _buffer.WriteVInt(posDelta);
                             }
 
-                            if (indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0)
+                            if (_indexOptions >= FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS)
                             {
                                 //System.out.println("write=" + pos.startOffset + "," + pos.endOffset);
-                                int offsetDelta = pos.startOffset - lastOffset;
-                                int offsetLength = pos.endOffset - pos.startOffset;
+                                var offsetDelta = pos.startOffset - lastOffset;
+                                var offsetLength = pos.endOffset - pos.startOffset;
                                 if (offsetLength != lastOffsetLength)
                                 {
-                                    buffer.WriteVInt(offsetDelta << 1 | 1);
-                                    buffer.WriteVInt(offsetLength);
+                                    _buffer.WriteVInt(offsetDelta << 1 | 1);
+                                    _buffer.WriteVInt(offsetLength);
                                 }
                                 else
                                 {
-                                    buffer.WriteVInt(offsetDelta << 1);
+                                    _buffer.WriteVInt(offsetDelta << 1);
                                 }
                                 lastOffset = pos.startOffset;
                                 lastOffsetLength = offsetLength;
@@ -361,73 +359,79 @@ namespace Lucene.Net.Codecs.Pulsing
 
                             if (payloadLength > 0)
                             {
-                                Debug.Debug.Assert((storePayloads);
-                                buffer.WriteBytes(pos.payload.Bytes, 0, pos.payload.Length);
+                                Debug.Assert(_storePayloads);
+                                _buffer.WriteBytes(pos.payload.Bytes, 0, pos.payload.Length);
                             }
                         }
                     }
                 }
-                else if (indexOptions == FieldInfo.IndexOptions_e.DOCS_AND_FREQS)
+                else switch (_indexOptions)
                 {
-                    int lastDocID = 0;
-                    for (int posIDX = 0; posIDX < pendingCount; posIDX++)
+                    case FieldInfo.IndexOptions.DOCS_AND_FREQS:
                     {
-                        Position doc = pending[posIDX];
-                        int delta = doc.docID - lastDocID;
-                        Debug.Debug.Assert((doc.termFreq != 0);
-
-                        if (doc.termFreq == 1)
-                        {
-                            buffer.WriteVInt((delta << 1) | 1);
-                        }
-                        else
+                        var lastDocId = 0;
+                        for (var posIdx = 0; posIdx < _pendingCount; posIdx++)
                         {
-                            buffer.WriteVInt(delta << 1);
-                            buffer.WriteVInt(doc.termFreq);
+                            var doc = _pending[posIdx];
+                            var delta = doc.docID - lastDocId;
+
+                            Debug.Assert(doc.termFreq != 0);
+
+                            if (doc.termFreq == 1)
+                            {
+                                _buffer.WriteVInt((delta << 1) | 1);
+                            }
+                            else
+                            {
+                                _buffer.WriteVInt(delta << 1);
+                                _buffer.WriteVInt(doc.termFreq);
+                            }
+                            lastDocId = doc.docID;
                         }
-                        lastDocID = doc.docID;
                     }
-                }
-                else if (indexOptions == FieldInfo.IndexOptions_e.DOCS_ONLY)
-                {
-                    int lastDocID = 0;
-                    for (int posIDX = 0; posIDX < pendingCount; posIDX++)
+                        break;
+                    case FieldInfo.IndexOptions.DOCS_ONLY:
                     {
-                        Position doc = pending[posIDX];
-                        buffer.WriteVInt(doc.docID - lastDocID);
-                        lastDocID = doc.docID;
+                        var lastDocId = 0;
+                        for (var posIdx = 0; posIdx < _pendingCount; posIdx++)
+                        {
+                            var doc = _pending[posIdx];
+                            _buffer.WriteVInt(doc.docID - lastDocId);
+                            lastDocId = doc.docID;
+                        }
                     }
+                        break;
                 }
 
-                state.bytes = new byte[(int) buffer.FilePointer];
-                buffer.WriteTo((sbyte[])(Array)state.bytes, 0);
-                buffer.Reset();
+                state.BYTES = new byte[(int) _buffer.FilePointer];
+                _buffer.WriteTo((sbyte[])(Array)state.BYTES, 0);
+                _buffer.Reset();
             }
-            pendingCount = 0;
+            _pendingCount = 0;
         }
 
-        public override void EncodeTerm(long[] empty, DataOutput output, FieldInfo fieldInfo, BlockTermState _state,
-            bool absolute)
+        public override void EncodeTerm(long[] empty, DataOutput output, FieldInfo fieldInfo, BlockTermState state,
+            bool abs)
         {
-            PulsingTermState state = (PulsingTermState) _state;
-            Debug.Debug.Assert((empty.Length == 0);
-            this.absolute = this.absolute || absolute;
-            if (state.bytes == null)
+            var _state = (PulsingTermState) state;
+            Debug.Assert(empty.Length == 0);
+            _absolute = _absolute || abs;
+            if (_state.BYTES == null)
             {
-                _wrappedPostingsWriter.EncodeTerm(longs, buffer, fieldInfo, state.wrappedState, this.absolute);
-                for (int i = 0; i < longsSize; i++)
+                _wrappedPostingsWriter.EncodeTerm(_longs, _buffer, fieldInfo, _state.WRAPPED_STATE, _absolute);
+                for (var i = 0; i < _longsSize; i++)
                 {
-                    output.WriteVLong(longs[i]);
+                    output.WriteVLong(_longs[i]);
                 }
-                buffer.WriteTo(output);
-                buffer.Reset();
-                this.absolute = false;
+                _buffer.WriteTo(output);
+                _buffer.Reset();
+                _absolute = false;
             }
             else
             {
-                output.WriteVInt(state.bytes.Length);
-                output.WriteBytes(state.bytes, 0, state.bytes.Length);
-                this.absolute = this.absolute || absolute;
+                output.WriteVInt(_state.BYTES.Length);
+                output.WriteBytes(_state.BYTES, 0, _state.BYTES.Length);
+                _absolute = _absolute || abs;
             }
         }
 
@@ -441,16 +445,16 @@ namespace Lucene.Net.Codecs.Pulsing
                 return;
             }
 
-            String summaryFileName = IndexFileNames.SegmentFileName(segmentState.SegmentInfo.Name,
-                segmentState.SegmentSuffix, SUMMARY_EXTENSION);
+            var summaryFileName = IndexFileNames.SegmentFileName(_segmentState.SegmentInfo.Name,
+                _segmentState.SegmentSuffix, SUMMARY_EXTENSION);
             IndexOutput output = null;
             try
             {
                 output =
-                    segmentState.Directory.CreateOutput(summaryFileName, segmentState.Context);
+                    _segmentState.Directory.CreateOutput(summaryFileName, _segmentState.Context);
                 CodecUtil.WriteHeader(output, CODEC, VERSION_CURRENT);
-                output.WriteVInt(fields.Count);
-                foreach (FieldMetaData field in fields)
+                output.WriteVInt(_fields.Count);
+                foreach (var field in _fields)
                 {
                     output.WriteVInt(field.FieldNumber);
                     output.WriteVInt(field.LongsSize);
@@ -464,48 +468,43 @@ namespace Lucene.Net.Codecs.Pulsing
         }
 
         // Pushes pending positions to the wrapped codec
-        private void push()
+        private void Push()
         {
-            // if (DEBUG) System.out.println("PW now push @ " + pendingCount + " wrapped=" + wrappedPostingsWriter);
-            Debug.Debug.Assert((pendingCount == pending.Length);
+            Debug.Assert(_pendingCount == _pending.Length);
 
             _wrappedPostingsWriter.StartTerm();
 
             // Flush all buffered docs
-            if (indexOptions.Value.CompareTo(FieldInfo.IndexOptions_e.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
+            if (_indexOptions >= FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
             {
                 Position doc = null;
 
-                foreach(Position pos in pending)
+                foreach(var pos in _pending)
                 {
                     if (doc == null)
                     {
                         doc = pos;
-                        // if (DEBUG) System.out.println("PW: wrapped.startDoc docID=" + doc.docID + " tf=" + doc.termFreq);
                         _wrappedPostingsWriter.StartDoc(doc.docID, doc.termFreq);
                     }
                     else if (doc.docID != pos.docID)
                     {
-                        Debug.Debug.Assert((pos.docID > doc.docID);
-                        // if (DEBUG) System.out.println("PW: wrapped.finishDoc");
+                        Debug.Assert(pos.docID > doc.docID);
                         _wrappedPostingsWriter.FinishDoc();
                         doc = pos;
-                        // if (DEBUG) System.out.println("PW: wrapped.startDoc docID=" + doc.docID + " tf=" + doc.termFreq);
                         _wrappedPostingsWriter.StartDoc(doc.docID, doc.termFreq);
                     }
-                    // if (DEBUG) System.out.println("PW:   wrapped.addPos pos=" + pos.pos);
                     _wrappedPostingsWriter.AddPosition(pos.pos, pos.payload, pos.startOffset, pos.endOffset);
                 }
                 //wrappedPostingsWriter.finishDoc();
             }
             else
             {
-                foreach(Position doc in pending)
+                foreach(var doc in _pending)
                 {
-                    _wrappedPostingsWriter.StartDoc(doc.docID, indexOptions == FieldInfo.IndexOptions_e.DOCS_ONLY ? 0 : doc.termFreq);
+                    _wrappedPostingsWriter.StartDoc(doc.docID, _indexOptions == FieldInfo.IndexOptions.DOCS_ONLY ? 0 : doc.termFreq);
                 }
             }
-            pendingCount = -1;
+            _pendingCount = -1;
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6e900565/src/Lucene.Net.Core/Codecs/PostingsConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/PostingsConsumer.cs b/src/Lucene.Net.Core/Codecs/PostingsConsumer.cs
index 8515972..65710df 100644
--- a/src/Lucene.Net.Core/Codecs/PostingsConsumer.cs
+++ b/src/Lucene.Net.Core/Codecs/PostingsConsumer.cs
@@ -63,7 +63,7 @@ namespace Lucene.Net.Codecs
         /// <code>freq</code> will be -1 when term frequencies are omitted
         /// for the field.
         /// </summary>
-        public abstract void StartDoc(int docID, int freq);
+        public abstract void StartDoc(int docId, int freq);
 
         /// <summary>
         /// Add a new position & payload, and start/end offset.  A


Mime
View raw message