lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [61/62] [abbrv] lucenenet git commit: Lucene.Net.Core.Util: Deleted obsolete files that are no longer in use
Date Sat, 01 Apr 2017 01:09:54 GMT
Lucene.Net.Core.Util: Deleted obsolete files that are no longer in use


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

Branch: refs/heads/api-work
Commit: 4ac99619192ea084f4d10098fe8f86ef79497b32
Parents: 8feb64e
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Apr 1 06:07:08 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sat Apr 1 07:52:04 2017 +0700

----------------------------------------------------------------------
 .../Util/AverageGuessMemoryModel.cs             |  90 ------
 src/Lucene.Net.Core/Util/BitVector.cs           | 315 -------------------
 src/Lucene.Net.Core/Util/Cache/Cache.cs         | 129 --------
 .../Util/Cache/SimpleLRUCache.cs                | 166 ----------
 .../Util/Cache/SimpleMapCache.cs                | 141 ---------
 .../Util/CloseableThreadLocal-old.cs            | 104 ------
 src/Lucene.Net.Core/Util/IdentityDictionary.cs  |  64 ----
 src/Lucene.Net.Core/Util/MemoryModel.cs         |  44 ---
 src/Lucene.Net.Core/Util/ReaderUtil.cs          | 122 -------
 src/Lucene.Net.Core/Util/ScorerDocQueue.cs      | 275 ----------------
 src/Lucene.Net.Core/Util/SortedVIntList.cs      | 289 -----------------
 src/Lucene.Net.Core/Util/SorterTemplate.cs      | 224 -------------
 src/Lucene.Net.Core/project.json                |  28 +-
 13 files changed, 2 insertions(+), 1989 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/AverageGuessMemoryModel.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/AverageGuessMemoryModel.cs b/src/Lucene.Net.Core/Util/AverageGuessMemoryModel.cs
deleted file mode 100644
index 1511905..0000000
--- a/src/Lucene.Net.Core/Util/AverageGuessMemoryModel.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary> An average, best guess, MemoryModel that should work okay on most systems.
-    /// 
-    /// </summary>
-    public class AverageGuessMemoryModel:MemoryModel
-    {
-        public AverageGuessMemoryModel()
-        {
-            InitBlock();
-        }
-
-        private void  InitBlock()
-        {
-            sizes = new IdentityDictionary<Type, int>()
-                        {
-                            {typeof (bool), 1},
-                            {typeof (byte), 1},
-                            {typeof(sbyte), 1},
-                            {typeof (char), 2},
-                            {typeof (short), 2},
-                            {typeof (int), 4},
-                            {typeof (float), 4},
-                            {typeof (double), 8},
-                            {typeof (long), 8}
-                        };
-        }
-        // best guess primitive sizes
-        private System.Collections.Generic.Dictionary<Type, int> sizes;
-        
-        /*
-        * (non-Javadoc)
-        * 
-        * <see cref="Lucene.Net.Util.MemoryModel.getArraySize()"/>
-        */
-
-        public override int ArraySize
-        {
-            get { return 16; }
-        }
-
-        /*
-        * (non-Javadoc)
-        * 
-        * <see cref="Lucene.Net.Util.MemoryModel.getClassSize()"/>
-        */
-
-        public override int ClassSize
-        {
-            get { return 8; }
-        }
-
-        /* (non-Javadoc)
-        * <see cref="Lucene.Net.Util.MemoryModel.getPrimitiveSize(java.lang.Class)"/>
-        */
-        public override int GetPrimitiveSize(Type clazz)
-        {
-            return sizes[clazz];
-        }
-        
-        /* (non-Javadoc)
-        * <see cref="Lucene.Net.Util.MemoryModel.getReferenceSize()"/>
-        */
-
-        public override int ReferenceSize
-        {
-            get { return 4; }
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/BitVector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/BitVector.cs b/src/Lucene.Net.Core/Util/BitVector.cs
deleted file mode 100644
index e2b65d6..0000000
--- a/src/Lucene.Net.Core/Util/BitVector.cs
+++ /dev/null
@@ -1,315 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using Lucene.Net.Support;
-using Directory = Lucene.Net.Store.Directory;
-using IndexInput = Lucene.Net.Store.IndexInput;
-using IndexOutput = Lucene.Net.Store.IndexOutput;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary>Optimized implementation of a vector of bits.  This is more-or-less like
-    /// java.util.BitSet, but also includes the following:
-    /// <list type="bullet">
-    /// <item>a count() method, which efficiently computes the number of one bits;</item>
-    /// <item>optimized read from and write to disk;</item>
-    /// <item>inlinable get() method;</item>
-    /// <item>store and load, as bit set or d-gaps, depending on sparseness;</item> 
-    /// </list>
-    /// </summary>
-    public sealed class BitVector : ICloneable
-    {
-        
-        private byte[] bits;
-        private int size;
-        private int count;
-        
-        /// <summary>Constructs a vector capable of holding <c>n</c> bits. </summary>
-        public BitVector(int n)
-        {
-            size = n;
-            bits = new byte[(size >> 3) + 1];
-            count = 0;
-        }
-        
-        internal BitVector(byte[] bits, int size)
-        {
-            this.bits = bits;
-            this.size = size;
-            count = -1;
-        }
-        
-        public System.Object Clone()
-        {
-            byte[] copyBits = new byte[bits.Length];
-            Array.Copy(bits, 0, copyBits, 0, bits.Length);
-            BitVector clone = new BitVector(copyBits, size);
-            clone.count = count;
-            return clone;
-        }
-        
-        /// <summary>Sets the value of <c>bit</c> to one. </summary>
-        public void  Set(int bit)
-        {
-            if (bit >= size)
-            {
-                throw new System. IndexOutOfRangeException("Index of bound " + bit);
-            }
-            bits[bit >> 3] |= (byte) (1 << (bit & 7));
-            count = - 1;
-        }
-        
-        /// <summary>Sets the value of <c>bit</c> to true, and
-        /// returns true if bit was already set 
-        /// </summary>
-        public bool GetAndSet(int bit)
-        {
-            if (bit >= size)
-            {
-                throw new System. IndexOutOfRangeException("Index of bound " + bit);
-            }
-            int pos = bit >> 3;
-            int v = bits[pos];
-            int flag = 1 << (bit & 7);
-            if ((flag & v) != 0)
-                return true;
-            else
-            {
-                bits[pos] = (byte) (v | flag);
-                if (count != - 1)
-                    count++;
-                return false;
-            }
-        }
-        
-        /// <summary>Sets the value of <c>bit</c> to zero. </summary>
-        public void  Clear(int bit)
-        {
-            if (bit >= size)
-            {
-                throw new System.IndexOutOfRangeException("Index of bound " + bit);
-            }
-            bits[bit >> 3] &= (byte) (~ (1 << (bit & 7)));
-            count = - 1;
-        }
-        
-        /// <summary>Returns <c>true</c> if <c>bit</c> is one and
-        /// <c>false</c> if it is zero. 
-        /// </summary>
-        public bool Get(int bit)
-        {
-            System.Diagnostics.Debug.Assert(bit >= 0 && bit < size, "bit " + bit + " is out of bounds 0.." +(size - 1));
-            return (bits[bit >> 3] & (1 << (bit & 7))) != 0;
-        }
-        
-        /// <summary>Returns the number of bits in this vector.  This is also one greater than
-        /// the number of the largest valid bit number. 
-        /// </summary>
-        public int Size()
-        {
-            return size;
-        }
-        
-        /// <summary>Returns the total number of one bits in this vector.  This is efficiently
-        /// computed and cached, so that, if the vector is not changed, no
-        /// recomputation is done for repeated calls. 
-        /// </summary>
-        public int Count()
-        {
-            // if the vector has been modified
-            if (count == - 1)
-            {
-                int c = 0;
-                int end = bits.Length;
-                for (int i = 0; i < end; i++)
-                    c += BYTE_COUNTS[bits[i] & 0xFF]; // sum bits per byte
-                count = c;
-            }
-            return count;
-        }
-
-        /// <summary>
-        /// For testing 
-        /// </summary>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
-        public int GetRecomputedCount()
-        {
-            int c = 0;
-            int end = bits.Length;
-            for (int i = 0; i < end; i++)
-                c += BYTE_COUNTS[bits[i] & 0xFF];      // sum bits per byte
-            return c;
-        }
-        
-        private static readonly byte[] BYTE_COUNTS = new byte[]{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
-        
-        
-        /// <summary>Writes this vector to the file <c>name</c> in Directory
-        /// <c>d</c>, in a format that can be read by the constructor 
-        /// <see cref="BitVector(Directory, String)" />.  
-        /// </summary>
-        public void  Write(Directory d, System.String name)
-        {
-            IndexOutput output = d.CreateOutput(name);
-            try
-            {
-                if (IsSparse())
-                {
-                    WriteDgaps(output); // sparse bit-set more efficiently saved as d-gaps.
-                }
-                else
-                {
-                    WriteBits(output);
-                }
-            }
-            finally
-            {
-                output.Close();
-            }
-        }
-        
-        /// <summary>Write as a bit set </summary>
-        private void  WriteBits(IndexOutput output)
-        {
-            output.WriteInt(Size()); // write size
-            output.WriteInt(Count()); // write count
-            output.WriteBytes(bits, bits.Length);
-        }
-        
-        /// <summary>Write as a d-gaps list </summary>
-        private void  WriteDgaps(IndexOutput output)
-        {
-            output.WriteInt(- 1); // mark using d-gaps                         
-            output.WriteInt(Size()); // write size
-            output.WriteInt(Count()); // write count
-            int last = 0;
-            int n = Count();
-            int m = bits.Length;
-            for (int i = 0; i < m && n > 0; i++)
-            {
-                if (bits[i] != 0)
-                {
-                    output.WriteVInt(i - last);
-                    output.WriteByte(bits[i]);
-                    last = i;
-                    n -= BYTE_COUNTS[bits[i] & 0xFF];
-                }
-            }
-        }
-        
-        /// <summary>Indicates if the bit vector is sparse and should be saved as a d-gaps list, or dense, and should be saved as a bit set. </summary>
-        private bool IsSparse()
-        {
-            // note: order of comparisons below set to favor smaller values (no binary range search.)
-            // note: adding 4 because we start with ((int) -1) to indicate d-gaps format.
-            // note: we write the d-gap for the byte number, and the byte (bits[i]) itself, therefore
-            //       multiplying count by (8+8) or (8+16) or (8+24) etc.:
-            //       - first 8 for writing bits[i] (1 byte vs. 1 bit), and 
-            //       - second part for writing the byte-number d-gap as vint. 
-            // note: factor is for read/write of byte-arrays being faster than vints.  
-            int factor = 10;
-            if (bits.Length < (1 << 7))
-                return factor * (4 + (8 + 8) * Count()) < Size();
-            if (bits.Length < (1 << 14))
-                return factor * (4 + (8 + 16) * Count()) < Size();
-            if (bits.Length < (1 << 21))
-                return factor * (4 + (8 + 24) * Count()) < Size();
-            if (bits.Length < (1 << 28))
-                return factor * (4 + (8 + 32) * Count()) < Size();
-            return factor * (4 + (8 + 40) * Count()) < Size();
-        }
-        
-        /// <summary>Constructs a bit vector from the file <c>name</c> in Directory
-        /// <c>d</c>, as written by the <see cref="Write" /> method.
-        /// </summary>
-        public BitVector(Directory d, System.String name)
-        {
-            IndexInput input = d.OpenInput(name);
-            try
-            {
-                size = input.ReadInt(); // read size
-                if (size == - 1)
-                {
-                    ReadDgaps(input);
-                }
-                else
-                {
-                    ReadBits(input);
-                }
-            }
-            finally
-            {
-                input.Close();
-            }
-        }
-        
-        /// <summary>Read as a bit set </summary>
-        private void  ReadBits(IndexInput input)
-        {
-            count = input.ReadInt(); // read count
-            bits = new byte[(size >> 3) + 1]; // allocate bits
-            input.ReadBytes(bits, 0, bits.Length);
-        }
-        
-        /// <summary>read as a d-gaps list </summary>
-        private void  ReadDgaps(IndexInput input)
-        {
-            size = input.ReadInt(); // (re)read size
-            count = input.ReadInt(); // read count
-            bits = new byte[(size >> 3) + 1]; // allocate bits
-            int last = 0;
-            int n = Count();
-            while (n > 0)
-            {
-                last += input.ReadVInt();
-                bits[last] = input.ReadByte();
-                n -= BYTE_COUNTS[bits[last] & 0xFF];
-            }
-        }
-        
-        /// <summary> Retrieve a subset of this BitVector.
-        /// 
-        /// </summary>
-        /// <param name="start">starting index, inclusive
-        /// </param>
-        /// <param name="end">ending index, exclusive
-        /// </param>
-        /// <returns> subset
-        /// </returns>
-        public BitVector Subset(int start, int end)
-        {
-            if (start < 0 || end > Size() || end < start)
-                throw new System.IndexOutOfRangeException();
-            // Special case -- return empty vector is start == end
-            if (end == start)
-                return new BitVector(0);
-            byte[] bits = new byte[(Number.URShift((end - start - 1), 3)) + 1];
-            int s = Number.URShift(start, 3);
-            for (int i = 0; i < bits.Length; i++)
-            {
-                int cur = 0xFF & this.bits[i + s];
-                int next = i + s + 1 >= this.bits.Length?0:0xFF & this.bits[i + s + 1];
-                bits[i] = (byte) ((Number.URShift(cur, (start & 7))) | ((next << (8 - (start & 7)))));
-            }
-            int bitsToClear = (bits.Length * 8 - (end - start)) % 8;
-            bits[bits.Length - 1] &= (byte) (~ (0xFF << (8 - bitsToClear)));
-            return new BitVector(bits, end - start);
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/Cache/Cache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Cache/Cache.cs b/src/Lucene.Net.Core/Util/Cache/Cache.cs
deleted file mode 100644
index 0540e22..0000000
--- a/src/Lucene.Net.Core/Util/Cache/Cache.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace Lucene.Net.Util.Cache
-{
-    
-    
-    /// <summary> Base class for cache implementations.</summary>
-    public abstract class Cache<TKey, TValue> : IDisposable
-    {
-        
-        /// <summary> Simple Cache wrapper that synchronizes all
-        /// calls that access the cache. 
-        /// </summary>
-        internal class SynchronizedCache_Renamed_Class : Cache<TKey, TValue>
-        {
-            internal System.Object mutex;
-            internal Cache<TKey,TValue> cache;
-
-            internal SynchronizedCache_Renamed_Class(Cache<TKey, TValue> cache)
-            {
-                this.cache = cache;
-                this.mutex = this;
-            }
-
-            internal SynchronizedCache_Renamed_Class(Cache<TKey, TValue> cache, System.Object mutex)
-            {
-                this.cache = cache;
-                this.mutex = mutex;
-            }
-            
-            public override void Put(TKey key, TValue value_Renamed)
-            {
-                lock (mutex)
-                {
-                    cache.Put(key, value_Renamed);
-                }
-            }
-            
-            public override TValue Get(System.Object key)
-            {
-                lock (mutex)
-                {
-                    return cache.Get(key);
-                }
-            }
-            
-            public override bool ContainsKey(System.Object key)
-            {
-                lock (mutex)
-                {
-                    return cache.ContainsKey(key);
-                }
-            }
-            
-            protected override void Dispose(bool disposing)
-            {
-                lock (mutex)
-                {
-                    cache.Dispose();
-                }
-            }
-            
-            internal override Cache<TKey,TValue> GetSynchronizedCache()
-            {
-                return this;
-            }
-        }
-        
-        /// <summary> Returns a thread-safe cache backed by the specified cache. 
-        /// In order to guarantee thread-safety, all access to the backed cache must
-        /// be accomplished through the returned cache.
-        /// </summary>
-        public static Cache<TKey, TValue> SynchronizedCache(Cache<TKey, TValue> cache)
-        {
-            return cache.GetSynchronizedCache();
-        }
-        
-        /// <summary> Called by <see cref="SynchronizedCache(Cache{TKey,TValue})" />. This method
-        /// returns a <see cref="SynchronizedCache" /> instance that wraps
-        /// this instance by default and can be overridden to return
-        /// e. g. subclasses of <see cref="SynchronizedCache" /> or this
-        /// in case this cache is already synchronized.
-        /// </summary>
-        internal virtual Cache<TKey, TValue> GetSynchronizedCache()
-        {
-            return new SynchronizedCache_Renamed_Class(this);
-        }
-        
-        /// <summary> Puts a (key, value)-pair into the cache. </summary>
-        public abstract void  Put(TKey key, TValue value_Renamed);
-        
-        /// <summary> Returns the value for the given key. </summary>
-        public abstract TValue Get(System.Object key);
-        
-        /// <summary> Returns whether the given key is in this cache. </summary>
-        public abstract bool ContainsKey(System.Object key);
-
-        /// <summary> Closes the cache.</summary>
-        [Obsolete("Use Dispose() instead")]
-        public void Close()
-        {
-            Dispose();
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected abstract void Dispose(bool disposing);
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/Cache/SimpleLRUCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Cache/SimpleLRUCache.cs b/src/Lucene.Net.Core/Util/Cache/SimpleLRUCache.cs
deleted file mode 100644
index 8f9b6fa..0000000
--- a/src/Lucene.Net.Core/Util/Cache/SimpleLRUCache.cs
+++ /dev/null
@@ -1,166 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using System.Collections.Generic;
-
-namespace Lucene.Net.Util.Cache
-{
-    public class SimpleLRUCache<TKey, TValue> : SimpleMapCache<TKey, TValue>
-    {
-        /// <summary>
-        /// The maximum number of items to cache.
-        /// </summary>
-        private int capacity;
-
-        /// <summary>
-        /// The list to efficiently maintain the LRU state.
-        /// </summary>
-        private LinkedList<ListValueEntry<TKey, TValue>> list;
-
-        /// <summary>
-        /// The dictionary to hash into any location in the list.
-        /// </summary>
-        private Dictionary<TKey, LinkedListNode<ListValueEntry<TKey, TValue>>> lookup;
-
-        /// <summary>
-        /// The node instance to use/re-use when adding an item to the cache.
-        /// </summary>
-        private LinkedListNode<ListValueEntry<TKey, TValue>> openNode;
-
-        public SimpleLRUCache(int Capacity)
-        {
-            this.capacity = Capacity;
-            this.list = new LinkedList<ListValueEntry<TKey, TValue>>();
-            this.lookup = new Dictionary<TKey, LinkedListNode<ListValueEntry<TKey, TValue>>>(Capacity + 1);
-            this.openNode = new LinkedListNode<ListValueEntry<TKey, TValue>>(new ListValueEntry<TKey, TValue>(default(TKey), default(TValue)));
-        }
-
-        public override void Put(TKey Key, TValue Value)
-        {
-            if (Get(Key) == null)
-            {
-                this.openNode.Value.ItemKey = Key;
-                this.openNode.Value.ItemValue = Value;
-                this.list.AddFirst(this.openNode);
-                this.lookup.Add(Key, this.openNode);
-
-                if (this.list.Count > this.capacity)
-                {
-                    // last node is to be removed and saved for the next addition to the cache
-                    this.openNode = this.list.Last;
-
-                    // remove from list & dictionary
-                    this.list.RemoveLast();
-                    this.lookup.Remove(this.openNode.Value.ItemKey);
-                }
-                else
-                {
-                    // still filling the cache, create a new open node for the next time
-                    this.openNode = new LinkedListNode<ListValueEntry<TKey, TValue>>(new ListValueEntry<TKey, TValue>(default(TKey), default(TValue)));
-                }
-            }
-        }
-
-        public override TValue Get(object Key)
-        {
-            LinkedListNode<ListValueEntry<TKey, TValue>> node = null;
-            if (!this.lookup.TryGetValue((TKey)Key, out node))
-            {
-                return default(TValue);
-            }
-            this.list.Remove(node);
-            this.list.AddFirst(node);
-            return node.Value.ItemValue;
-        }
-
-        /// <summary>
-        /// Container to hold the key and value to aid in removal from 
-        /// the <see cref="lookup"/> dictionary when an item is removed from cache.
-        /// </summary>
-        class ListValueEntry<K, V> where K : TKey 
-                                   where V : TValue
-        {
-            internal V ItemValue;
-            internal K ItemKey;
-
-            internal ListValueEntry(K key, V value)
-            {
-                this.ItemKey = key;
-                this.ItemValue = value;
-            }
-        }
-    }
-
-
-#region NOT_USED_FROM_JLCA_PORT
-/*
-  
- //
- // This is the oringal port as it was generated via JLCA.
- // This code is not used.  It's here for referance only.
- //
-  
-
-    /// <summary> Simple LRU cache implementation that uses a LinkedHashMap.
-    /// This cache is not synchronized, use <see cref="Cache.SynchronizedCache(Cache)" />
-    /// if needed.
-    /// 
-    /// </summary>
-    public class SimpleLRUCache:SimpleMapCache
-    {
-        private class AnonymousClassLinkedHashMap : LinkedHashMap
-        {
-            public AnonymousClassLinkedHashMap(SimpleLRUCache enclosingInstance)
-            {
-                InitBlock(enclosingInstance);
-            }
-            private void  InitBlock(SimpleLRUCache enclosingInstance)
-            {
-                this.enclosingInstance = enclosingInstance;
-            }
-            private SimpleLRUCache enclosingInstance;
-            public SimpleLRUCache Enclosing_Instance
-            {
-                get
-                {
-                    return enclosingInstance;
-                }
-                
-            }
-            protected internal virtual bool RemoveEldestEntry(System.Collections.DictionaryEntry eldest)
-            {
-                return size() > Enclosing_Instance.cacheSize;
-            }
-        }
-        private const float LOADFACTOR = 0.75f;
-        
-        private int cacheSize;
-        
-        /// <summary> Creates a last-recently-used cache with the specified size. </summary>
-        public SimpleLRUCache(int cacheSize):base(null)
-        {
-            this.cacheSize = cacheSize;
-            int capacity = (int) System.Math.Ceiling(cacheSize / LOADFACTOR) + 1;
-            
-            base.map = new AnonymousClassLinkedHashMap(this, capacity, LOADFACTOR, true);
-        }
-    }
-*/
-#endregion
-
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/Cache/SimpleMapCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Cache/SimpleMapCache.cs b/src/Lucene.Net.Core/Util/Cache/SimpleMapCache.cs
deleted file mode 100644
index 2e9f510..0000000
--- a/src/Lucene.Net.Core/Util/Cache/SimpleMapCache.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using System.Collections.Generic;
-
-namespace Lucene.Net.Util.Cache
-{
-    
-    /// <summary> Simple cache implementation that uses a HashMap to store (key, value) pairs.
-    /// This cache is not synchronized, use <see cref="Cache{TKey, TValue}.SynchronizedCache(Cache{TKey, TValue})" />
-    /// if needed.
-    /// </summary>
-    public class SimpleMapCache<TKey, TValue> : Cache<TKey, TValue>
-    {
-        internal System.Collections.Generic.Dictionary<TKey, TValue> map;
-
-        public SimpleMapCache()
-            : this(new System.Collections.Generic.Dictionary<TKey, TValue>())
-        {
-        }
-
-        public SimpleMapCache(System.Collections.Generic.Dictionary<TKey, TValue> map)
-        {
-            this.map = map;
-        }
-        
-        public override TValue Get(System.Object key)
-        {
-            return map[(TKey)key];
-        }
-        
-        public override void  Put(TKey key, TValue value_Renamed)
-        {
-            map[key] = value_Renamed;
-        }
-        
-        public override bool ContainsKey(System.Object key)
-        {
-            return map.ContainsKey((TKey)key);
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            // do nothing
-        }
-
-        /// <summary> Returns a Set containing all keys in this cache.</summary>
-        public virtual System.Collections.Generic.HashSet<TKey> KeySet()
-        {
-            return new HashSet<TKey>(map.Keys);
-        }
-        
-        internal override Cache<TKey, TValue> GetSynchronizedCache()
-        {
-            return new SynchronizedSimpleMapCache(this);
-        }
-        
-        // Why does does this use both inheritance and composition?
-        private class SynchronizedSimpleMapCache : SimpleMapCache<TKey, TValue>
-        {
-            private System.Object mutex;
-            private SimpleMapCache<TKey, TValue> cache;
-
-            private bool isDisposed;
-
-            internal SynchronizedSimpleMapCache(SimpleMapCache<TKey, TValue> cache)
-            {
-                this.cache = cache;
-                this.mutex = this;
-            }
-            
-            public override void  Put(TKey key, TValue value_Renamed)
-            {
-                lock (mutex)
-                {
-                    cache.Put(key, value_Renamed);
-                }
-            }
-            
-            public override TValue Get(System.Object key)
-            {
-                lock (mutex)
-                {
-                    return cache.Get(key);
-                }
-            }
-            
-            public override bool ContainsKey(System.Object key)
-            {
-                lock (mutex)
-                {
-                    return cache.ContainsKey(key);
-                }
-            }
-            
-            protected override void Dispose(bool disposing)
-            {
-                lock (mutex)
-                {
-                    if (isDisposed) return;
-
-                    if (disposing)
-                    {
-                        cache.Dispose(disposing);
-                    }
-
-                    isDisposed = true;
-                    base.Dispose(disposing);
-                }
-            }
-            
-            public override HashSet<TKey> KeySet()
-            {
-                lock (mutex)
-                {
-                    return cache.KeySet();
-                }
-            }
-            
-            internal override Cache<TKey, TValue> GetSynchronizedCache()
-            {
-                return this;
-            }
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/CloseableThreadLocal-old.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/CloseableThreadLocal-old.cs b/src/Lucene.Net.Core/Util/CloseableThreadLocal-old.cs
deleted file mode 100644
index 536eaf0..0000000
--- a/src/Lucene.Net.Core/Util/CloseableThreadLocal-old.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary>Java's builtin ThreadLocal has a serious flaw:
-    /// it can take an arbitrarily long amount of time to
-    /// dereference the things you had stored in it, even once the
-    /// ThreadLocal instance itself is no longer referenced.
-    /// This is because there is single, master map stored for
-    /// each thread, which all ThreadLocals share, and that
-    /// master map only periodically purges "stale" entries.
-    /// 
-    /// While not technically a memory leak, because eventually
-    /// the memory will be reclaimed, it can take a long time
-    /// and you can easily hit OutOfMemoryError because from the
-    /// GC's standpoint the stale entries are not reclaimaible.
-    /// 
-    /// This class works around that, by only enrolling
-    /// WeakReference values into the ThreadLocal, and
-    /// separately holding a hard reference to each stored
-    /// value.  When you call {@link #close}, these hard
-    /// references are cleared and then GC is freely able to
-    /// reclaim space by objects stored in it. 
-    /// </summary>
-    
-    public class CloseableThreadLocal
-    {
-        
-        [ThreadStatic]
-        static SupportClass.WeakHashTable slots;
-        
-        public /*protected internal*/ virtual System.Object InitialValue()
-        {
-            return null;
-        }
-
-        public virtual System.Object Get()
-        {
-            object value;
-
-            if (slots == null)
-            {
-                value = InitialValue();
-                if (value != null)
-                    Set(value);
-
-                return value;
-            }
-
-            if (slots.ContainsKey(this))
-            {
-                return slots[this];
-            }
-            else
-            {
-                value = InitialValue();
-                slots[this] = value;
-                return value;
-            }
-        }
-        
-        public virtual void  Set(System.Object object_Renamed)
-        {
-            //+-- For Debuging
-            if (SupportClass.CloseableThreadLocalProfiler.EnableCloseableThreadLocalProfiler == true)
-            {
-                lock (SupportClass.CloseableThreadLocalProfiler.Instances)
-                {
-                    SupportClass.CloseableThreadLocalProfiler.Instances.Add(new WeakReference(object_Renamed));
-                }
-            }
-            //+--
-
-            if (slots == null)
-                slots = new SupportClass.WeakHashTable();
-
-            slots[this] = object_Renamed;    
-        }
-        
-        public virtual void  Close()
-        {
-            if(slots != null)
-                slots.Remove(this);
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/IdentityDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/IdentityDictionary.cs b/src/Lucene.Net.Core/Util/IdentityDictionary.cs
deleted file mode 100644
index f23f91f..0000000
--- a/src/Lucene.Net.Core/Util/IdentityDictionary.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Lucene.Net.Util
-{
-    /// <summary>
-    /// A class that mimics Java's IdentityHashMap in that it determines
-    /// object equality solely on ReferenceEquals rather than (possibly overloaded)
-    /// object.Equals().
-    /// 
-    /// NOTE: Java's documentation on IdentityHashMap says that it also uses
-    ///       ReferenceEquals on it's Values as well.  This class does not follow this behavior
-    /// </summary>
-    /// <typeparam name="TKey">The type of the keys in the dictionary</typeparam>
-    /// <typeparam name="TValue">The type of the values in the dictionary</typeparam>
-    public class IdentityDictionary<TKey, TValue> : Dictionary<TKey, TValue>
-    {
-        public IdentityDictionary(IDictionary<TKey, TValue> other) : base(other, new IdentityComparer())
-        { }
-
-        public IdentityDictionary(int capacity) : base(capacity, new IdentityComparer())
-        { }
-
-        public IdentityDictionary() : this(16)
-        { }
-
-        class IdentityComparer : IEqualityComparer<TKey>
-        {
-            public bool Equals(TKey x, TKey y)
-            {
-                return ReferenceEquals(x, y);
-            }
-
-            public int GetHashCode(TKey obj)
-            {
-                return obj.GetHashCode();
-            }
-        }
-    }
-}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/MemoryModel.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/MemoryModel.cs b/src/Lucene.Net.Core/Util/MemoryModel.cs
deleted file mode 100644
index d97b5f9..0000000
--- a/src/Lucene.Net.Core/Util/MemoryModel.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary> Returns primitive memory sizes for estimating RAM usage.
-    /// 
-    /// </summary>
-    public abstract class MemoryModel
-    {
-        /// <value> size of array beyond contents </value>
-        public abstract int ArraySize { get; }
-
-        /// <value> Class size overhead </value>
-        public abstract int ClassSize { get; }
-
-        /// <param name="clazz">a primitive Class - bool, byte, char, short, long, float,
-        /// short, double, int
-        /// </param>
-        /// <returns> the size in bytes of given primitive Class
-        /// </returns>
-        public abstract int GetPrimitiveSize(System.Type clazz);
-
-        /// <value> size of reference </value>
-        public abstract int ReferenceSize { get; }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/ReaderUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/ReaderUtil.cs b/src/Lucene.Net.Core/Util/ReaderUtil.cs
deleted file mode 100644
index 1d23ccf..0000000
--- a/src/Lucene.Net.Core/Util/ReaderUtil.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using Lucene.Net.Support;
-using IndexReader = Lucene.Net.Index.IndexReader;
-
-namespace Lucene.Net.Util
-{
-    /// <summary>
-    /// Common util methods for dealing with <see cref="IndexReader" />s.
-    /// </summary>
-    public class ReaderUtil
-    {
-        /// <summary>Gathers sub-readers from reader into a List.</summary>
-        /// <param name="allSubReaders"></param>
-        /// <param name="reader"></param>
-        public static void GatherSubReaders(System.Collections.Generic.IList<IndexReader> allSubReaders, IndexReader reader)
-        {
-            IndexReader[] subReaders = reader.GetSequentialSubReaders();
-            if (subReaders == null)
-            {
-                // Add the reader itself, and do not recurse
-                allSubReaders.Add(reader);
-            }
-            else
-            {
-                for (int i = 0; i < subReaders.Length; i++)
-                {
-                    GatherSubReaders(allSubReaders, subReaders[i]);
-                }
-            }
-        }
-        
-        /// <summary> Returns sub IndexReader that contains the given document id.
-        /// 
-        /// </summary>
-        /// <param name="doc">id of document
-        /// </param>
-        /// <param name="reader">parent reader
-        /// </param>
-        /// <returns> sub reader of parent which contains the specified doc id
-        /// </returns>
-        public static IndexReader SubReader(int doc, IndexReader reader)
-        {
-            var subReadersList = new System.Collections.Generic.List<IndexReader>();
-            ReaderUtil.GatherSubReaders(subReadersList, reader);
-            IndexReader[] subReaders = subReadersList.ToArray();
-            int[] docStarts = new int[subReaders.Length];
-            int maxDoc = 0;
-            for (int i = 0; i < subReaders.Length; i++)
-            {
-                docStarts[i] = maxDoc;
-                maxDoc += subReaders[i].MaxDoc;
-            }
-            return subReaders[ReaderUtil.SubIndex(doc, docStarts)];
-        }
-        
-        /// <summary> Returns sub-reader subIndex from reader.
-        /// 
-        /// </summary>
-        /// <param name="reader">parent reader
-        /// </param>
-        /// <param name="subIndex">index of desired sub reader
-        /// </param>
-        /// <returns> the subreader at subINdex
-        /// </returns>
-        public static IndexReader SubReader(IndexReader reader, int subIndex)
-        {
-            var subReadersList = new System.Collections.Generic.List<IndexReader>();
-            ReaderUtil.GatherSubReaders(subReadersList, reader);
-            IndexReader[] subReaders = subReadersList.ToArray();
-            return subReaders[subIndex];
-        }
-        
-        
-        /// <summary> Returns index of the searcher/reader for document <c>n</c> in the
-        /// array used to construct this searcher/reader.
-        /// </summary>
-        public static int SubIndex(int n, int[] docStarts)
-        {
-            // find
-            // searcher/reader for doc n:
-            int size = docStarts.Length;
-            int lo = 0; // search starts array
-            int hi = size - 1; // for first element less than n, return its index
-            while (hi >= lo)
-            {
-                int mid = Number.URShift((lo + hi), 1);
-                int midValue = docStarts[mid];
-                if (n < midValue)
-                    hi = mid - 1;
-                else if (n > midValue)
-                    lo = mid + 1;
-                else
-                {
-                    // found a match
-                    while (mid + 1 < size && docStarts[mid + 1] == midValue)
-                    {
-                        mid++; // scan to last match
-                    }
-                    return mid;
-                }
-            }
-            return hi;
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/ScorerDocQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/ScorerDocQueue.cs b/src/Lucene.Net.Core/Util/ScorerDocQueue.cs
deleted file mode 100644
index 02e83bd..0000000
--- a/src/Lucene.Net.Core/Util/ScorerDocQueue.cs
+++ /dev/null
@@ -1,275 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-/* Derived from Lucene.Net.Util.PriorityQueue of March 2005 */
-using System;
-using Lucene.Net.Support;
-using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
-using Scorer = Lucene.Net.Search.Scorer;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary>A ScorerDocQueue maintains a partial ordering of its Scorers such that the
-    /// least Scorer can always be found in constant time.  Put()'s and pop()'s
-    /// require log(size) time. The ordering is by Scorer.doc().
-    /// </summary>
-    public class ScorerDocQueue
-    {
-        // later: SpansQueue for spans with doc and term positions
-        private HeapedScorerDoc[] heap;
-        private int maxSize;
-        private int size;
-        
-        private class HeapedScorerDoc
-        {
-            private void  InitBlock(ScorerDocQueue enclosingInstance)
-            {
-                this.enclosingInstance = enclosingInstance;
-            }
-            private ScorerDocQueue enclosingInstance;
-            public ScorerDocQueue Enclosing_Instance
-            {
-                get
-                {
-                    return enclosingInstance;
-                }
-                
-            }
-            internal Scorer scorer;
-            internal int doc;
-            
-            internal HeapedScorerDoc(ScorerDocQueue enclosingInstance, Scorer s):this(enclosingInstance, s, s.DocID())
-            {
-            }
-            
-            internal HeapedScorerDoc(ScorerDocQueue enclosingInstance, Scorer scorer, int doc)
-            {
-                InitBlock(enclosingInstance);
-                this.scorer = scorer;
-                this.doc = doc;
-            }
-            
-            internal virtual void  Adjust()
-            {
-                doc = scorer.DocID();
-            }
-        }
-        
-        private HeapedScorerDoc topHSD; // same as heap[1], only for speed
-        
-        /// <summary>Create a ScorerDocQueue with a maximum size. </summary>
-        public ScorerDocQueue(int maxSize)
-        {
-            // assert maxSize >= 0;
-            size = 0;
-            int heapSize = maxSize + 1;
-            heap = new HeapedScorerDoc[heapSize];
-            this.maxSize = maxSize;
-            topHSD = heap[1]; // initially null
-        }
-        
-        /// <summary> Adds a Scorer to a ScorerDocQueue in log(size) time.
-        /// If one tries to add more Scorers than maxSize
-        /// a RuntimeException (ArrayIndexOutOfBound) is thrown.
-        /// </summary>
-        public void  Put(Scorer scorer)
-        {
-            size++;
-            heap[size] = new HeapedScorerDoc(this, scorer);
-            UpHeap();
-        }
-        
-        /// <summary> Adds a Scorer to the ScorerDocQueue in log(size) time if either
-        /// the ScorerDocQueue is not full, or not lessThan(scorer, top()).
-        /// </summary>
-        /// <param name="scorer">
-        /// </param>
-        /// <returns> true if scorer is added, false otherwise.
-        /// </returns>
-        public virtual bool Insert(Scorer scorer)
-        {
-            if (size < maxSize)
-            {
-                Put(scorer);
-                return true;
-            }
-            else
-            {
-                int docNr = scorer.DocID();
-                if ((size > 0) && (!(docNr < topHSD.doc)))
-                {
-                    // heap[1] is top()
-                    heap[1] = new HeapedScorerDoc(this, scorer, docNr);
-                    DownHeap();
-                    return true;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-        }
-        
-        /// <summary>Returns the least Scorer of the ScorerDocQueue in constant time.
-        /// Should not be used when the queue is empty.
-        /// </summary>
-        public Scorer Top()
-        {
-            // assert size > 0;
-            return topHSD.scorer;
-        }
-        
-        /// <summary>Returns document number of the least Scorer of the ScorerDocQueue
-        /// in constant time.
-        /// Should not be used when the queue is empty.
-        /// </summary>
-        public int TopDoc()
-        {
-            // assert size > 0;
-            return topHSD.doc;
-        }
-        
-        public float TopScore()
-        {
-            // assert size > 0;
-            return topHSD.scorer.Score();
-        }
-        
-        public bool TopNextAndAdjustElsePop()
-        {
-            return CheckAdjustElsePop(topHSD.scorer.NextDoc() != DocIdSetIterator.NO_MORE_DOCS);
-        }
-        
-        public bool TopSkipToAndAdjustElsePop(int target)
-        {
-            return CheckAdjustElsePop(topHSD.scorer.Advance(target) != DocIdSetIterator.NO_MORE_DOCS);
-        }
-        
-        private bool CheckAdjustElsePop(bool cond)
-        {
-            if (cond)
-            {
-                // see also adjustTop
-                topHSD.doc = topHSD.scorer.DocID();
-            }
-            else
-            {
-                // see also popNoResult
-                heap[1] = heap[size]; // move last to first
-                heap[size] = null;
-                size--;
-            }
-            DownHeap();
-            return cond;
-        }
-        
-        /// <summary>Removes and returns the least scorer of the ScorerDocQueue in log(size)
-        /// time.
-        /// Should not be used when the queue is empty.
-        /// </summary>
-        public Scorer Pop()
-        {
-            // assert size > 0;
-            Scorer result = topHSD.scorer;
-            PopNoResult();
-            return result;
-        }
-        
-        /// <summary>Removes the least scorer of the ScorerDocQueue in log(size) time.
-        /// Should not be used when the queue is empty.
-        /// </summary>
-        private void  PopNoResult()
-        {
-            heap[1] = heap[size]; // move last to first
-            heap[size] = null;
-            size--;
-            DownHeap(); // adjust heap
-        }
-        
-        /// <summary>Should be called when the scorer at top changes doc() value.
-        /// Still log(n) worst case, but it's at least twice as fast to <c>
-        /// { pq.top().change(); pq.adjustTop(); }
-        /// </c> instead of <c>
-        /// { o = pq.pop(); o.change(); pq.push(o); }
-        /// </c>
-        /// </summary>
-        public void  AdjustTop()
-        {
-            // assert size > 0;
-            topHSD.Adjust();
-            DownHeap();
-        }
-        
-        /// <summary>Returns the number of scorers currently stored in the ScorerDocQueue. </summary>
-        public int Size()
-        {
-            return size;
-        }
-        
-        /// <summary>Removes all entries from the ScorerDocQueue. </summary>
-        public void  Clear()
-        {
-            for (int i = 0; i <= size; i++)
-            {
-                heap[i] = null;
-            }
-            size = 0;
-        }
-        
-        private void  UpHeap()
-        {
-            int i = size;
-            HeapedScorerDoc node = heap[i]; // save bottom node
-            int j = Number.URShift(i, 1);
-            while ((j > 0) && (node.doc < heap[j].doc))
-            {
-                heap[i] = heap[j]; // shift parents down
-                i = j;
-                j = Number.URShift(j, 1);
-            }
-            heap[i] = node; // install saved node
-            topHSD = heap[1];
-        }
-        
-        private void  DownHeap()
-        {
-            int i = 1;
-            HeapedScorerDoc node = heap[i]; // save top node
-            int j = i << 1; // find smaller child
-            int k = j + 1;
-            if ((k <= size) && (heap[k].doc < heap[j].doc))
-            {
-                j = k;
-            }
-            while ((j <= size) && (heap[j].doc < node.doc))
-            {
-                heap[i] = heap[j]; // shift up child
-                i = j;
-                j = i << 1;
-                k = j + 1;
-                if (k <= size && (heap[k].doc < heap[j].doc))
-                {
-                    j = k;
-                }
-            }
-            heap[i] = node; // install saved node
-            topHSD = heap[1];
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/SortedVIntList.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/SortedVIntList.cs b/src/Lucene.Net.Core/Util/SortedVIntList.cs
deleted file mode 100644
index 2b33aca..0000000
--- a/src/Lucene.Net.Core/Util/SortedVIntList.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using Lucene.Net.Support;
-using DocIdSet = Lucene.Net.Search.DocIdSet;
-using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary> Stores and iterate on sorted integers in compressed form in RAM. <br/>
-    /// The code for compressing the differences between ascending integers was
-    /// borrowed from <see cref="Lucene.Net.Store.IndexInput" /> and
-    /// <see cref="Lucene.Net.Store.IndexOutput" />.<p/>
-    /// <b>NOTE:</b> this class assumes the stored integers are doc Ids (hence why it
-    /// extends <see cref="DocIdSet" />). Therefore its <see cref="Iterator()" /> assumes <see cref="DocIdSetIterator.NO_MORE_DOCS" />
-    /// can be used as sentinel. If you intent to use
-    /// this value, then make sure it's not used during search flow.
-    /// </summary>
-    public class SortedVIntList:DocIdSet
-    {
-        private class AnonymousClassDocIdSetIterator:DocIdSetIterator
-        {
-            public AnonymousClassDocIdSetIterator(SortedVIntList enclosingInstance)
-            {
-                InitBlock(enclosingInstance);
-            }
-            private void  InitBlock(SortedVIntList enclosingInstance)
-            {
-                this.enclosingInstance = enclosingInstance;
-            }
-            private SortedVIntList enclosingInstance;
-            public SortedVIntList Enclosing_Instance
-            {
-                get
-                {
-                    return enclosingInstance;
-                }
-                
-            }
-            internal int bytePos = 0;
-            internal int lastInt = 0;
-            internal int doc = - 1;
-            
-            private void  Advance()
-            {
-                // See Lucene.Net.Store.IndexInput.readVInt()
-                sbyte b = Enclosing_Instance.bytes[bytePos++];
-                lastInt += (b & Lucene.Net.Util.SortedVIntList.VB1);
-                for (int s = Lucene.Net.Util.SortedVIntList.BIT_SHIFT; (b & ~ Lucene.Net.Util.SortedVIntList.VB1) != 0; s += Lucene.Net.Util.SortedVIntList.BIT_SHIFT)
-                {
-                    b = Enclosing_Instance.bytes[bytePos++];
-                    lastInt += ((b & Lucene.Net.Util.SortedVIntList.VB1) << s);
-                }
-            }
-            
-            public override int DocID()
-            {
-                return doc;
-            }
-            
-            public override int NextDoc()
-            {
-                if (bytePos >= Enclosing_Instance.lastBytePos)
-                {
-                    doc = NO_MORE_DOCS;
-                }
-                else
-                {
-                    Advance();
-                    doc = lastInt;
-                }
-                return doc;
-            }
-            
-            public override int Advance(int target)
-            {
-                while (bytePos < Enclosing_Instance.lastBytePos)
-                {
-                    Advance();
-                    if (lastInt >= target)
-                    {
-                        return doc = lastInt;
-                    }
-                }
-                return doc = NO_MORE_DOCS;
-            }
-        }
-        /// <summary>When a BitSet has fewer than 1 in BITS2VINTLIST_SIZE bits set,
-        /// a SortedVIntList representing the index numbers of the set bits
-        /// will be smaller than that BitSet.
-        /// </summary>
-        internal const int BITS2VINTLIST_SIZE = 8;
-        
-        private int size;
-        private sbyte[] bytes;
-        private int lastBytePos;
-        
-        /// <summary>  Create a SortedVIntList from all elements of an array of integers.
-        /// 
-        /// </summary>
-        /// <param name="sortedInts"> A sorted array of non negative integers.
-        /// </param>
-        public SortedVIntList(params int[] sortedInts):this(sortedInts, sortedInts.Length)
-        {
-        }
-        
-        /// <summary> Create a SortedVIntList from an array of integers.</summary>
-        /// <param name="sortedInts"> An array of sorted non negative integers.
-        /// </param>
-        /// <param name="inputSize">  The number of integers to be used from the array.
-        /// </param>
-        public SortedVIntList(int[] sortedInts, int inputSize)
-        {
-            SortedVIntListBuilder builder = new SortedVIntListBuilder(this);
-            for (int i = 0; i < inputSize; i++)
-            {
-                builder.AddInt(sortedInts[i]);
-            }
-            builder.Done();
-        }
-        
-        /// <summary> Create a SortedVIntList from a BitSet.</summary>
-        /// <param name="bits"> A bit set representing a set of integers.
-        /// </param>
-        public SortedVIntList(System.Collections.BitArray bits)
-        {
-            SortedVIntListBuilder builder = new SortedVIntListBuilder(this);
-            int nextInt = BitSetSupport.NextSetBit(bits, 0);
-            while (nextInt != - 1)
-            {
-                builder.AddInt(nextInt);
-                nextInt = BitSetSupport.NextSetBit(bits, nextInt + 1);
-            }
-            builder.Done();
-        }
-        
-        /// <summary> Create a SortedVIntList from an OpenBitSet.</summary>
-        /// <param name="bits"> A bit set representing a set of integers.
-        /// </param>
-        public SortedVIntList(OpenBitSet bits)
-        {
-            SortedVIntListBuilder builder = new SortedVIntListBuilder(this);
-            int nextInt = bits.NextSetBit(0);
-            while (nextInt != - 1)
-            {
-                builder.AddInt(nextInt);
-                nextInt = bits.NextSetBit(nextInt + 1);
-            }
-            builder.Done();
-        }
-        
-        /// <summary> Create a SortedVIntList.</summary>
-        /// <param name="docIdSetIterator"> An iterator providing document numbers as a set of integers.
-        /// This DocIdSetIterator is iterated completely when this constructor
-        /// is called and it must provide the integers in non
-        /// decreasing order.
-        /// </param>
-        public SortedVIntList(DocIdSetIterator docIdSetIterator)
-        {
-            SortedVIntListBuilder builder = new SortedVIntListBuilder(this);
-            int doc;
-            while ((doc = docIdSetIterator.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
-            {
-                builder.AddInt(doc);
-            }
-            builder.Done();
-        }
-        
-        
-        private class SortedVIntListBuilder
-        {
-            private void  InitBlock(SortedVIntList enclosingInstance)
-            {
-                this.enclosingInstance = enclosingInstance;
-            }
-            private SortedVIntList enclosingInstance;
-            public SortedVIntList Enclosing_Instance
-            {
-                get
-                {
-                    return enclosingInstance;
-                }
-                
-            }
-            private int lastInt = 0;
-            
-            internal SortedVIntListBuilder(SortedVIntList enclosingInstance)
-            {
-                InitBlock(enclosingInstance);
-                Enclosing_Instance.InitBytes();
-                lastInt = 0;
-            }
-            
-            internal virtual void  AddInt(int nextInt)
-            {
-                int diff = nextInt - lastInt;
-                if (diff < 0)
-                {
-                    throw new System.ArgumentException("Input not sorted or first element negative.");
-                }
-                
-                if ((Enclosing_Instance.lastBytePos + Enclosing_Instance.MAX_BYTES_PER_INT) > Enclosing_Instance.bytes.Length)
-                {
-                    // biggest possible int does not fit
-                    Enclosing_Instance.ResizeBytes((Enclosing_Instance.bytes.Length * 2) + Enclosing_Instance.MAX_BYTES_PER_INT);
-                }
-                
-                // See Lucene.Net.Store.IndexOutput.writeVInt()
-                while ((diff & ~ Lucene.Net.Util.SortedVIntList.VB1) != 0)
-                {
-                    // The high bit of the next byte needs to be set.
-                    Enclosing_Instance.bytes[Enclosing_Instance.lastBytePos++] = (sbyte) ((diff & Lucene.Net.Util.SortedVIntList.VB1) | ~ Lucene.Net.Util.SortedVIntList.VB1);
-                    diff = Number.URShift(diff, Lucene.Net.Util.SortedVIntList.BIT_SHIFT);
-                }
-                Enclosing_Instance.bytes[Enclosing_Instance.lastBytePos++] = (sbyte) diff; // Last byte, high bit not set.
-                Enclosing_Instance.size++;
-                lastInt = nextInt;
-            }
-            
-            internal virtual void  Done()
-            {
-                Enclosing_Instance.ResizeBytes(Enclosing_Instance.lastBytePos);
-            }
-        }
-        
-        
-        private void  InitBytes()
-        {
-            size = 0;
-            bytes = new sbyte[128]; // initial byte size
-            lastBytePos = 0;
-        }
-        
-        private void  ResizeBytes(int newSize)
-        {
-            if (newSize != bytes.Length)
-            {
-                sbyte[] newBytes = new sbyte[newSize];
-                Array.Copy(bytes, 0, newBytes, 0, lastBytePos);
-                bytes = newBytes;
-            }
-        }
-        
-        private const int VB1 = 0x7F;
-        private const int BIT_SHIFT = 7;
-        private int MAX_BYTES_PER_INT = (31 / BIT_SHIFT) + 1;
-
-        /// <value> The total number of sorted integers. </value>
-        public virtual int Size
-        {
-            get { return size; }
-        }
-
-        /// <value> The size of the byte array storing the compressed sorted integers. </value>
-        public virtual int ByteSize
-        {
-            get { return bytes.Length; }
-        }
-
-        /// <summary>This DocIdSet implementation is cacheable. </summary>
-        public override bool IsCacheable
-        {
-            get { return true; }
-        }
-
-        /// <returns>    An iterator over the sorted integers.
-        /// </returns>
-        public override DocIdSetIterator Iterator()
-        {
-            return new AnonymousClassDocIdSetIterator(this);
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/Util/SorterTemplate.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/SorterTemplate.cs b/src/Lucene.Net.Core/Util/SorterTemplate.cs
deleted file mode 100644
index fae324f..0000000
--- a/src/Lucene.Net.Core/Util/SorterTemplate.cs
+++ /dev/null
@@ -1,224 +0,0 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- * http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-
-namespace Lucene.Net.Util
-{
-    
-    /// <summary> Borrowed from Cglib. Allows custom swap so that two arrays can be sorted
-    /// at the same time.
-    /// </summary>
-    public abstract class SorterTemplate
-    {
-        private const int MERGESORT_THRESHOLD = 12;
-        private const int QUICKSORT_THRESHOLD = 7;
-        
-        abstract protected internal void  Swap(int i, int j);
-        abstract protected internal int Compare(int i, int j);
-        
-        public virtual void  QuickSort(int lo, int hi)
-        {
-            QuickSortHelper(lo, hi);
-            InsertionSort(lo, hi);
-        }
-        
-        private void  QuickSortHelper(int lo, int hi)
-        {
-            for (; ; )
-            {
-                int diff = hi - lo;
-                if (diff <= QUICKSORT_THRESHOLD)
-                {
-                    break;
-                }
-                int i = (hi + lo) / 2;
-                if (Compare(lo, i) > 0)
-                {
-                    Swap(lo, i);
-                }
-                if (Compare(lo, hi) > 0)
-                {
-                    Swap(lo, hi);
-                }
-                if (Compare(i, hi) > 0)
-                {
-                    Swap(i, hi);
-                }
-                int j = hi - 1;
-                Swap(i, j);
-                i = lo;
-                int v = j;
-                for (; ; )
-                {
-                    while (Compare(++i, v) < 0)
-                    {
-                        /* nothing */ ;
-                    }
-                    while (Compare(--j, v) > 0)
-                    {
-                        /* nothing */ ;
-                    }
-                    if (j < i)
-                    {
-                        break;
-                    }
-                    Swap(i, j);
-                }
-                Swap(i, hi - 1);
-                if (j - lo <= hi - i + 1)
-                {
-                    QuickSortHelper(lo, j);
-                    lo = i + 1;
-                }
-                else
-                {
-                    QuickSortHelper(i + 1, hi);
-                    hi = j;
-                }
-            }
-        }
-        
-        private void  InsertionSort(int lo, int hi)
-        {
-            for (int i = lo + 1; i <= hi; i++)
-            {
-                for (int j = i; j > lo; j--)
-                {
-                    if (Compare(j - 1, j) > 0)
-                    {
-                        Swap(j - 1, j);
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-            }
-        }
-        
-        protected internal virtual void  MergeSort(int lo, int hi)
-        {
-            int diff = hi - lo;
-            if (diff <= MERGESORT_THRESHOLD)
-            {
-                InsertionSort(lo, hi);
-                return ;
-            }
-            int mid = lo + diff / 2;
-            MergeSort(lo, mid);
-            MergeSort(mid, hi);
-            Merge(lo, mid, hi, mid - lo, hi - mid);
-        }
-        
-        private void  Merge(int lo, int pivot, int hi, int len1, int len2)
-        {
-            if (len1 == 0 || len2 == 0)
-            {
-                return ;
-            }
-            if (len1 + len2 == 2)
-            {
-                if (Compare(pivot, lo) < 0)
-                {
-                    Swap(pivot, lo);
-                }
-                return ;
-            }
-            int first_cut, second_cut;
-            int len11, len22;
-            if (len1 > len2)
-            {
-                len11 = len1 / 2;
-                first_cut = lo + len11;
-                second_cut = Lower(pivot, hi, first_cut);
-                len22 = second_cut - pivot;
-            }
-            else
-            {
-                len22 = len2 / 2;
-                second_cut = pivot + len22;
-                first_cut = Upper(lo, pivot, second_cut);
-                len11 = first_cut - lo;
-            }
-            Rotate(first_cut, pivot, second_cut);
-            int new_mid = first_cut + len22;
-            Merge(lo, first_cut, new_mid, len11, len22);
-            Merge(new_mid, second_cut, hi, len1 - len11, len2 - len22);
-        }
-        
-        private void  Rotate(int lo, int mid, int hi)
-        {
-            int lot = lo;
-            int hit = mid - 1;
-            while (lot < hit)
-            {
-                Swap(lot++, hit--);
-            }
-            lot = mid; hit = hi - 1;
-            while (lot < hit)
-            {
-                Swap(lot++, hit--);
-            }
-            lot = lo; hit = hi - 1;
-            while (lot < hit)
-            {
-                Swap(lot++, hit--);
-            }
-        }
-        
-        private int Lower(int lo, int hi, int val)
-        {
-            int len = hi - lo;
-            while (len > 0)
-            {
-                int half = len / 2;
-                int mid = lo + half;
-                if (Compare(mid, val) < 0)
-                {
-                    lo = mid + 1;
-                    len = len - half - 1;
-                }
-                else
-                {
-                    len = half;
-                }
-            }
-            return lo;
-        }
-        
-        private int Upper(int lo, int hi, int val)
-        {
-            int len = hi - lo;
-            while (len > 0)
-            {
-                int half = len / 2;
-                int mid = lo + half;
-                if (Compare(val, mid) < 0)
-                {
-                    len = half;
-                }
-                else
-                {
-                    lo = mid + 1;
-                    len = len - half - 1;
-                }
-            }
-            return lo;
-        }
-    }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/4ac99619/src/Lucene.Net.Core/project.json
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/project.json b/src/Lucene.Net.Core/project.json
index ed6637b..5ad4624 100644
--- a/src/Lucene.Net.Core/project.json
+++ b/src/Lucene.Net.Core/project.json
@@ -13,25 +13,13 @@
       "buildOptions": {
         "define": [ "FEATURE_TASKMERGESCHEDULER", "NETSTANDARD" ],
         "compile": {
-          "exclude": [
-            "Util/Cache/*"
-          ],
           "excludeFiles": [
             "RectangularArrays.cs",
             "Index/ConcurrentMergeScheduler.cs",
             "Support/Deflater.cs",
             "Support/Inflater.cs",
             "Support/SharpZipLib.cs",
-            "Support/StreamUtils.cs",
-            "Util/AverageGuessMemoryModel.cs",
-            "Util/BitVector.cs",
-            "Util/CloseableThreadLocal-old.cs",
-            "Util/IdentityDictionary.cs",
-            "Util/MemoryModel.cs",
-            "Util/ReaderUtil.cs",
-            "Util/ScorerDocQueue.cs",
-            "Util/SortedVIntList.cs",
-            "Util/SorterTemplate.cs"
+            "Support/StreamUtils.cs"
           ]
         }
       },
@@ -64,20 +52,8 @@
           "FEATURE_LIFETIME_SERVICE"
         ],
         "compile": {
-          "exclude": [
-            "Util/Cache/*"
-          ],
           "excludeFiles": [
-            "RectangularArrays.cs",
-            "Util/AverageGuessMemoryModel.cs",
-            "Util/BitVector.cs",
-            "Util/CloseableThreadLocal-old.cs",
-            "Util/IdentityDictionary.cs",
-            "Util/MemoryModel.cs",
-            "Util/ReaderUtil.cs",
-            "Util/ScorerDocQueue.cs",
-            "Util/SortedVIntList.cs",
-            "Util/SorterTemplate.cs"
+            "RectangularArrays.cs"
           ]
         }
       }


Mime
View raw message