lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pnas...@apache.org
Subject [1/3] Lucene.Net.Codecs/Memory porting part 1
Date Mon, 29 Sep 2014 07:23:55 GMT
Repository: lucenenet
Updated Branches:
  refs/heads/master d852d5b04 -> af4d125b5


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/af4d125b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
index 26ee255..a51df00 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
@@ -2,8 +2,9 @@
 using System.Diagnostics;
 using System.Collections.Generic;
 using Lucene.Net.Codecs.Memory;
+using Lucene.Net.Index;
 
-namespace org.apache.lucene.codecs.memory
+namespace Lucene.Net.Codecs.Memory
 {
 
 	/*
@@ -24,44 +25,44 @@ namespace org.apache.lucene.codecs.memory
 	 */
 
 
-	using FieldInfo = org.apache.lucene.index.FieldInfo;
-	using IndexFileNames = org.apache.lucene.index.IndexFileNames;
-	using SegmentWriteState = org.apache.lucene.index.SegmentWriteState;
-	using ByteArrayDataOutput = org.apache.lucene.store.ByteArrayDataOutput;
-	using IndexOutput = org.apache.lucene.store.IndexOutput;
-	using ArrayUtil = org.apache.lucene.util.ArrayUtil;
-	using BytesRef = org.apache.lucene.util.BytesRef;
-	using IOUtils = org.apache.lucene.util.IOUtils;
-	using IntsRef = org.apache.lucene.util.IntsRef;
-	using MathUtil = org.apache.lucene.util.MathUtil;
-	using Builder = org.apache.lucene.util.fst.Builder;
-	using INPUT_TYPE = org.apache.lucene.util.fst.FST.INPUT_TYPE;
-	using FST = org.apache.lucene.util.fst.FST;
-	using PositiveIntOutputs = org.apache.lucene.util.fst.PositiveIntOutputs;
-	using Util = org.apache.lucene.util.fst.Util;
-	using BlockPackedWriter = org.apache.lucene.util.packed.BlockPackedWriter;
-	using MonotonicBlockPackedWriter = org.apache.lucene.util.packed.MonotonicBlockPackedWriter;
-	using FormatAndBits = org.apache.lucene.util.packed.PackedInts.FormatAndBits;
-	using PackedInts = org.apache.lucene.util.packed.PackedInts;
+	using FieldInfo = index.FieldInfo;
+	using IndexFileNames = index.IndexFileNames;
+	using SegmentWriteState = index.SegmentWriteState;
+	using ByteArrayDataOutput = store.ByteArrayDataOutput;
+	using IndexOutput = store.IndexOutput;
+	using ArrayUtil = util.ArrayUtil;
+	using BytesRef = util.BytesRef;
+	using IOUtils = util.IOUtils;
+	using IntsRef = util.IntsRef;
+	using MathUtil = util.MathUtil;
+	using Builder = util.fst.Builder;
+	using INPUT_TYPE = util.fst.FST.INPUT_TYPE;
+	using FST = util.fst.FST;
+	using PositiveIntOutputs = util.fst.PositiveIntOutputs;
+	using Util = util.fst.Util;
+	using BlockPackedWriter = util.packed.BlockPackedWriter;
+	using MonotonicBlockPackedWriter = util.packed.MonotonicBlockPackedWriter;
+	using FormatAndBits = util.packed.PackedInts.FormatAndBits;
+	using PackedInts = util.packed.PackedInts;
 
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.VERSION_CURRENT;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.VERSION_CURRENT;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.BLOCK_SIZE;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.BLOCK_SIZE;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.BYTES;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.BYTES;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.NUMBER;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.NUMBER;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.FST;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.FST;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.DELTA_COMPRESSED;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.DELTA_COMPRESSED;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.GCD_COMPRESSED;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.GCD_COMPRESSED;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.TABLE_COMPRESSED;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.TABLE_COMPRESSED;
 //JAVA TO C# CONVERTER TODO TASK: This Java 'import static' statement cannot be converted to .NET:
-	import static org.apache.lucene.codecs.memory.MemoryDocValuesProducer.UNCOMPRESSED;
+	import static Lucene.Net.Codecs.Memory.MemoryDocValuesProducer.UNCOMPRESSED;
 
 	/// <summary>
 	/// Writer for <seealso cref="MemoryDocValuesFormat"/>
@@ -72,9 +73,7 @@ namespace org.apache.lucene.codecs.memory
 	  internal readonly int maxDoc;
 	  internal readonly float acceptableOverheadRatio;
 
-//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: MemoryDocValuesConsumer(org.apache.lucene.index.SegmentWriteState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension, float acceptableOverheadRatio) throws java.io.IOException
-	  internal MemoryDocValuesConsumer(SegmentWriteState state, string dataCodec, string dataExtension, string metaCodec, string metaExtension, float acceptableOverheadRatio)
+        internal MemoryDocValuesConsumer(SegmentWriteState state, string dataCodec, string dataExtension, string metaCodec, string metaExtension, float acceptableOverheadRatio)
 	  {
 		this.acceptableOverheadRatio = acceptableOverheadRatio;
 		maxDoc = state.segmentInfo.DocCount;
@@ -99,14 +98,14 @@ namespace org.apache.lucene.codecs.memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void addNumericField(org.apache.lucene.index.FieldInfo field, Iterable<Number> values) throws java.io.IOException
+//ORIGINAL LINE: @Override public void addNumericField(index.FieldInfo field, Iterable<Number> values) throws java.io.IOException
 	  public override void addNumericField(FieldInfo field, IEnumerable<Number> values)
 	  {
 		addNumericField(field, values, true);
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: void addNumericField(org.apache.lucene.index.FieldInfo field, Iterable<Number> values, boolean optimizeStorage) throws java.io.IOException
+//ORIGINAL LINE: void addNumericField(index.FieldInfo field, Iterable<Number> values, boolean optimizeStorage) throws java.io.IOException
 	  internal virtual void addNumericField(FieldInfo field, IEnumerable<Number> values, bool optimizeStorage)
 	  {
 		meta.writeVInt(field.number);
@@ -188,7 +187,7 @@ namespace org.apache.lucene.codecs.memory
 		{
 		  // small number of unique values
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final int bitsPerValue = org.apache.lucene.util.packed.PackedInts.bitsRequired(uniqueValues.size()-1);
+//ORIGINAL LINE: final int bitsPerValue = util.packed.PackedInts.bitsRequired(uniqueValues.size()-1);
 		  int bitsPerValue = PackedInts.bitsRequired(uniqueValues.Count - 1);
 		  FormatAndBits formatAndBits = PackedInts.fastestFormatAndBits(maxDoc, bitsPerValue, acceptableOverheadRatio);
 		  if (formatAndBits.bitsPerValue == 8 && minValue >= sbyte.MinValue && maxValue <= sbyte.MaxValue)
@@ -218,7 +217,7 @@ namespace org.apache.lucene.codecs.memory
 			data.writeVInt(formatAndBits.bitsPerValue);
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.PackedInts.Writer writer = org.apache.lucene.util.packed.PackedInts.getWriterNoHeader(data, formatAndBits.format, maxDoc, formatAndBits.bitsPerValue, org.apache.lucene.util.packed.PackedInts.DEFAULT_BUFFER_SIZE);
+//ORIGINAL LINE: final util.packed.PackedInts.Writer writer = util.packed.PackedInts.getWriterNoHeader(data, formatAndBits.format, maxDoc, formatAndBits.bitsPerValue, util.packed.PackedInts.DEFAULT_BUFFER_SIZE);
 			PackedInts.Writer writer = PackedInts.getWriterNoHeader(data, formatAndBits.format, maxDoc, formatAndBits.bitsPerValue, PackedInts.DEFAULT_BUFFER_SIZE);
 			foreach (Number nv in values)
 			{
@@ -236,7 +235,7 @@ namespace org.apache.lucene.codecs.memory
 		  data.writeVInt(BLOCK_SIZE);
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.BlockPackedWriter writer = new org.apache.lucene.util.packed.BlockPackedWriter(data, BLOCK_SIZE);
+//ORIGINAL LINE: final util.packed.BlockPackedWriter writer = new util.packed.BlockPackedWriter(data, BLOCK_SIZE);
 		  BlockPackedWriter writer = new BlockPackedWriter(data, BLOCK_SIZE);
 		  foreach (Number nv in values)
 		  {
@@ -253,7 +252,7 @@ namespace org.apache.lucene.codecs.memory
 		  data.writeVInt(BLOCK_SIZE);
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.BlockPackedWriter writer = new org.apache.lucene.util.packed.BlockPackedWriter(data, BLOCK_SIZE);
+//ORIGINAL LINE: final util.packed.BlockPackedWriter writer = new util.packed.BlockPackedWriter(data, BLOCK_SIZE);
 		  BlockPackedWriter writer = new BlockPackedWriter(data, BLOCK_SIZE);
 		  foreach (Number nv in values)
 		  {
@@ -296,7 +295,7 @@ namespace org.apache.lucene.codecs.memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void addBinaryField(org.apache.lucene.index.FieldInfo field, final Iterable<org.apache.lucene.util.BytesRef> values) throws java.io.IOException
+//ORIGINAL LINE: @Override public void addBinaryField(index.FieldInfo field, final Iterable<util.BytesRef> values) throws java.io.IOException
 //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
 	  public override void addBinaryField(FieldInfo field, IEnumerable<BytesRef> values)
 	  {
@@ -358,7 +357,7 @@ namespace org.apache.lucene.codecs.memory
 		  meta.writeVInt(BLOCK_SIZE);
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.MonotonicBlockPackedWriter writer = new org.apache.lucene.util.packed.MonotonicBlockPackedWriter(data, BLOCK_SIZE);
+//ORIGINAL LINE: final util.packed.MonotonicBlockPackedWriter writer = new util.packed.MonotonicBlockPackedWriter(data, BLOCK_SIZE);
 		  MonotonicBlockPackedWriter writer = new MonotonicBlockPackedWriter(data, BLOCK_SIZE);
 		  long addr = 0;
 		  foreach (BytesRef v in values)
@@ -374,7 +373,7 @@ namespace org.apache.lucene.codecs.memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: private void writeFST(org.apache.lucene.index.FieldInfo field, Iterable<org.apache.lucene.util.BytesRef> values) throws java.io.IOException
+//ORIGINAL LINE: private void writeFST(index.FieldInfo field, Iterable<util.BytesRef> values) throws java.io.IOException
 	  private void writeFST(FieldInfo field, IEnumerable<BytesRef> values)
 	  {
 		meta.writeVInt(field.number);
@@ -426,7 +425,7 @@ namespace org.apache.lucene.codecs.memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void addSortedField(org.apache.lucene.index.FieldInfo field, Iterable<org.apache.lucene.util.BytesRef> values, Iterable<Number> docToOrd) throws java.io.IOException
+//ORIGINAL LINE: @Override public void addSortedField(index.FieldInfo field, Iterable<util.BytesRef> values, Iterable<Number> docToOrd) throws java.io.IOException
 	  public override void addSortedField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<Number> docToOrd)
 	  {
 		// write the ordinals as numerics
@@ -438,7 +437,7 @@ namespace org.apache.lucene.codecs.memory
 
 	  // note: this might not be the most efficient... but its fairly simple
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void addSortedSetField(org.apache.lucene.index.FieldInfo field, Iterable<org.apache.lucene.util.BytesRef> values, final Iterable<Number> docToOrdCount, final Iterable<Number> ords) throws java.io.IOException
+//ORIGINAL LINE: @Override public void addSortedSetField(index.FieldInfo field, Iterable<util.BytesRef> values, final Iterable<Number> docToOrdCount, final Iterable<Number> ords) throws java.io.IOException
 //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
 	  public override void addSortedSetField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<Number> docToOrdCount, IEnumerable<Number> ords)
 	  {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/af4d125b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs
index 8b36c0f..1c40d89 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesFormat.cs
@@ -1,73 +1,72 @@
-using org.apache.lucene.codecs.memory;
+/*
+ * 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 Lucene.Net.Index;
+using Lucene.Net.Util.Packed;
 
 namespace Lucene.Net.Codecs.Memory
 {
 
-	/*
-	 * 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.
-	 */
     /// <summary>
-	/// In-memory docvalues format </summary>
-	public class MemoryDocValuesFormat : DocValuesFormat
-	{
+    /// In-memory docvalues format </summary>
+    public class MemoryDocValuesFormat : DocValuesFormat
+    {
 
-	  /// <summary>
-	  /// Maximum length for each binary doc values field. </summary>
-	  public static readonly int MAX_BINARY_FIELD_LENGTH = (1 << 15) - 2;
+        /// <summary>Maximum length for each binary doc values field. </summary>
+        public static readonly int MAX_BINARY_FIELD_LENGTH = (1 << 15) - 2;
 
-	  internal readonly float acceptableOverheadRatio;
+        internal readonly float ACCEPTABLE_OVERHEAD_RATIO;
 
-	  /// <summary>
-	  /// Calls {@link #MemoryDocValuesFormat(float) 
-	  /// MemoryDocValuesFormat(PackedInts.DEFAULT)} 
-	  /// </summary>
-	  public MemoryDocValuesFormat() : this(PackedInts.DEFAULT)
-	  {
-	  }
+        internal const string DATA_CODEC = "MemoryDocValuesData";
+        internal const string DATA_EXTENSION = "mdvd";
+        internal const string METADATA_CODEC = "MemoryDocValuesMetadata";
+        internal const string METADATA_EXTENSION = "mdvm";
+    
+        /// <summary>
+        /// Calls {@link #MemoryDocValuesFormat(float) 
+        /// MemoryDocValuesFormat(PackedInts.DEFAULT)} 
+        /// </summary>
+        public MemoryDocValuesFormat() : this(PackedInts.DEFAULT)
+        {
+        }
 
-	  /// <summary>
-	  /// Creates a new MemoryDocValuesFormat with the specified
-	  /// <code>acceptableOverheadRatio</code> for NumericDocValues. </summary>
-	  /// <param name="acceptableOverheadRatio"> compression parameter for numerics. 
-	  ///        Currently this is only used when the number of unique values is small.
-	  ///        
-	  /// @lucene.experimental </param>
-	  public MemoryDocValuesFormat(float acceptableOverheadRatio) : base("Memory")
-	  {
-		this.acceptableOverheadRatio = acceptableOverheadRatio;
-	  }
+        /// <summary>
+        /// Creates a new MemoryDocValuesFormat with the specified
+        /// <code>acceptableOverheadRatio</code> for NumericDocValues. </summary>
+        /// <param name="acceptableOverheadRatio"> compression parameter for numerics. 
+        ///        Currently this is only used when the number of unique values is small.
+        ///        
+        /// @lucene.experimental </param>
+        public MemoryDocValuesFormat(float acceptableOverheadRatio) : base("Memory")
+        {
+            ACCEPTABLE_OVERHEAD_RATIO = acceptableOverheadRatio;
+        }
 
-//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.codecs.DocValuesConsumer fieldsConsumer(org.apache.lucene.index.SegmentWriteState state) throws java.io.IOException
-	  public override DocValuesConsumer fieldsConsumer(SegmentWriteState state)
-	  {
-		return new MemoryDocValuesConsumer(state, DATA_CODEC, DATA_EXTENSION, METADATA_CODEC, METADATA_EXTENSION, acceptableOverheadRatio);
-	  }
+        public override DocValuesConsumer FieldsConsumer(SegmentWriteState state)
+        {
+            return new MemoryDocValuesConsumer(state, DATA_CODEC, DATA_EXTENSION, METADATA_CODEC, METADATA_EXTENSION,
+                ACCEPTABLE_OVERHEAD_RATIO);
+        }
 
-//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.codecs.DocValuesProducer fieldsProducer(org.apache.lucene.index.SegmentReadState state) throws java.io.IOException
-	  public override DocValuesProducer fieldsProducer(SegmentReadState state)
-	  {
-		return new MemoryDocValuesProducer(state, DATA_CODEC, DATA_EXTENSION, METADATA_CODEC, METADATA_EXTENSION);
-	  }
+        public override DocValuesProducer FieldsProducer(SegmentReadState state)
+        {
+            return new MemoryDocValuesProducer(state, DATA_CODEC, DATA_EXTENSION, METADATA_CODEC, METADATA_EXTENSION);
+        }
 
-	  internal const string DATA_CODEC = "MemoryDocValuesData";
-	  internal const string DATA_EXTENSION = "mdvd";
-	  internal const string METADATA_CODEC = "MemoryDocValuesMetadata";
-	  internal const string METADATA_EXTENSION = "mdvm";
-	}
+    }
 
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/af4d125b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
index 5ab0b09..129aaf7 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
@@ -1,25 +1,25 @@
 /*
-	 * 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.
-	 */
+ * 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.Diagnostics;
 using Lucene.Net.Codecs.Sep;
-using org.apache.lucene.codecs.memory;
+using Lucene.Net.Index;
 
 namespace Lucene.Net.Codecs.Memory
 {
@@ -61,7 +61,7 @@ namespace Lucene.Net.Codecs.Memory
 	  internal const int VERSION_CURRENT = VERSION_CHECKSUM;
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: MemoryDocValuesProducer(org.apache.lucene.index.SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws java.io.IOException
+//ORIGINAL LINE: MemoryDocValuesProducer(index.SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws java.io.IOException
 	  internal MemoryDocValuesProducer(SegmentReadState state, string dataCodec, string dataExtension, string metaCodec, string metaExtension)
 	  {
 		maxDoc = state.segmentInfo.DocCount;
@@ -105,7 +105,7 @@ namespace Lucene.Net.Codecs.Memory
 		  string dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
 		  data = state.directory.openInput(dataName, state.context);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final int version2 = org.apache.lucene.codecs.CodecUtil.checkHeader(data, dataCodec, VERSION_START, VERSION_CURRENT);
+//ORIGINAL LINE: final int version2 = codecs.CodecUtil.checkHeader(data, dataCodec, VERSION_START, VERSION_CURRENT);
 		  int version2 = CodecUtil.checkHeader(data, dataCodec, VERSION_START, VERSION_CURRENT);
 		  if (version != version2)
 		  {
@@ -124,7 +124,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: private void readFields(org.apache.lucene.store.IndexInput meta, org.apache.lucene.index.FieldInfos infos) throws java.io.IOException
+//ORIGINAL LINE: private void readFields(store.IndexInput meta, index.FieldInfos infos) throws java.io.IOException
 	  private void readFields(IndexInput meta, FieldInfos infos)
 	  {
 		int fieldNumber = meta.readVInt();
@@ -200,7 +200,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public synchronized org.apache.lucene.index.NumericDocValues getNumeric(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: @Override public synchronized index.NumericDocValues getNumeric(index.FieldInfo field) throws java.io.IOException
 	  public override NumericDocValues getNumeric(FieldInfo field)
 	  {
 		  lock (this)
@@ -231,7 +231,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: private org.apache.lucene.index.NumericDocValues loadNumeric(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: private index.NumericDocValues loadNumeric(index.FieldInfo field) throws java.io.IOException
 	  private NumericDocValues loadNumeric(FieldInfo field)
 	  {
 		NumericEntry entry = numerics[field.number];
@@ -258,7 +258,7 @@ namespace Lucene.Net.Codecs.Memory
 //ORIGINAL LINE: final int bitsPerValue = data.readVInt();
 			int bitsPerValue = data.readVInt();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.PackedInts.Reader ordsReader = org.apache.lucene.util.packed.PackedInts.getReaderNoHeader(data, org.apache.lucene.util.packed.PackedInts.Format.byId(formatID), entry.packedIntsVersion, maxDoc, bitsPerValue);
+//ORIGINAL LINE: final util.packed.PackedInts.Reader ordsReader = util.packed.PackedInts.getReaderNoHeader(data, util.packed.PackedInts.Format.byId(formatID), entry.packedIntsVersion, maxDoc, bitsPerValue);
 			PackedInts.Reader ordsReader = PackedInts.getReaderNoHeader(data, PackedInts.Format.byId(formatID), entry.packedIntsVersion, maxDoc, bitsPerValue);
 			ramBytesUsed_Renamed.addAndGet(RamUsageEstimator.sizeOf(decode) + ordsReader.ramBytesUsed());
 			return new NumericDocValuesAnonymousInnerClassHelper(this, decode, ordsReader);
@@ -267,7 +267,7 @@ namespace Lucene.Net.Codecs.Memory
 //ORIGINAL LINE: final int blockSize = data.readVInt();
 			int blockSize = data.readVInt();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.BlockPackedReader reader = new org.apache.lucene.util.packed.BlockPackedReader(data, entry.packedIntsVersion, blockSize, maxDoc, false);
+//ORIGINAL LINE: final util.packed.BlockPackedReader reader = new util.packed.BlockPackedReader(data, entry.packedIntsVersion, blockSize, maxDoc, false);
 			BlockPackedReader reader = new BlockPackedReader(data, entry.packedIntsVersion, blockSize, maxDoc, false);
 			ramBytesUsed_Renamed.addAndGet(reader.ramBytesUsed());
 			return reader;
@@ -289,7 +289,7 @@ namespace Lucene.Net.Codecs.Memory
 //ORIGINAL LINE: final int quotientBlockSize = data.readVInt();
 			int quotientBlockSize = data.readVInt();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.BlockPackedReader quotientReader = new org.apache.lucene.util.packed.BlockPackedReader(data, entry.packedIntsVersion, quotientBlockSize, maxDoc, false);
+//ORIGINAL LINE: final util.packed.BlockPackedReader quotientReader = new util.packed.BlockPackedReader(data, entry.packedIntsVersion, quotientBlockSize, maxDoc, false);
 			BlockPackedReader quotientReader = new BlockPackedReader(data, entry.packedIntsVersion, quotientBlockSize, maxDoc, false);
 			ramBytesUsed_Renamed.addAndGet(quotientReader.ramBytesUsed());
 			return new NumericDocValuesAnonymousInnerClassHelper3(this, min, mult, quotientReader);
@@ -359,7 +359,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public synchronized org.apache.lucene.index.BinaryDocValues getBinary(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: @Override public synchronized index.BinaryDocValues getBinary(index.FieldInfo field) throws java.io.IOException
 	  public override BinaryDocValues getBinary(FieldInfo field)
 	  {
 		  lock (this)
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: private org.apache.lucene.index.BinaryDocValues loadBinary(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: private index.BinaryDocValues loadBinary(index.FieldInfo field) throws java.io.IOException
 	  private BinaryDocValues loadBinary(FieldInfo field)
 	  {
 		BinaryEntry entry = binaries[field.number];
@@ -383,7 +383,7 @@ namespace Lucene.Net.Codecs.Memory
 		PagedBytes bytes = new PagedBytes(16);
 		bytes.copy(data, entry.numBytes);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.PagedBytes.Reader bytesReader = bytes.freeze(true);
+//ORIGINAL LINE: final util.PagedBytes.Reader bytesReader = bytes.freeze(true);
 		PagedBytes.Reader bytesReader = bytes.freeze(true);
 		if (entry.minLength == entry.maxLength)
 		{
@@ -397,7 +397,7 @@ namespace Lucene.Net.Codecs.Memory
 		{
 		  data.seek(data.FilePointer + entry.missingBytes);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.packed.MonotonicBlockPackedReader addresses = new org.apache.lucene.util.packed.MonotonicBlockPackedReader(data, entry.packedIntsVersion, entry.blockSize, maxDoc, false);
+//ORIGINAL LINE: final util.packed.MonotonicBlockPackedReader addresses = new util.packed.MonotonicBlockPackedReader(data, entry.packedIntsVersion, entry.blockSize, maxDoc, false);
 		  MonotonicBlockPackedReader addresses = new MonotonicBlockPackedReader(data, entry.packedIntsVersion, entry.blockSize, maxDoc, false);
 		  ramBytesUsed_Renamed.addAndGet(bytes.ramBytesUsed() + addresses.ramBytesUsed());
 		  return new BinaryDocValuesAnonymousInnerClassHelper2(this, bytesReader, addresses);
@@ -447,7 +447,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.index.SortedDocValues getSorted(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: @Override public index.SortedDocValues getSorted(index.FieldInfo field) throws java.io.IOException
 	  public override SortedDocValues getSorted(FieldInfo field)
 	  {
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
@@ -470,27 +470,27 @@ namespace Lucene.Net.Codecs.Memory
 		  }
 		}
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.index.NumericDocValues docToOrd = getNumeric(field);
+//ORIGINAL LINE: final index.NumericDocValues docToOrd = getNumeric(field);
 		NumericDocValues docToOrd = getNumeric(field);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST<Long> fst = instance;
+//ORIGINAL LINE: final util.fst.FST<Long> fst = instance;
 		FST<long?> fst = instance;
 
 		// per-thread resources
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.BytesReader in = fst.getBytesReader();
+//ORIGINAL LINE: final util.fst.FST.BytesReader in = fst.getBytesReader();
 		FST.BytesReader @in = fst.BytesReader;
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.Arc<Long> firstArc = new org.apache.lucene.util.fst.FST.Arc<>();
+//ORIGINAL LINE: final util.fst.FST.Arc<Long> firstArc = new util.fst.FST.Arc<>();
 		FST.Arc<long?> firstArc = new FST.Arc<long?>();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.Arc<Long> scratchArc = new org.apache.lucene.util.fst.FST.Arc<>();
+//ORIGINAL LINE: final util.fst.FST.Arc<Long> scratchArc = new util.fst.FST.Arc<>();
 		FST.Arc<long?> scratchArc = new FST.Arc<long?>();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.IntsRef scratchInts = new org.apache.lucene.util.IntsRef();
+//ORIGINAL LINE: final util.IntsRef scratchInts = new util.IntsRef();
 		IntsRef scratchInts = new IntsRef();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.BytesRefFSTEnum<Long> fstEnum = new org.apache.lucene.util.fst.BytesRefFSTEnum<>(fst);
+//ORIGINAL LINE: final util.fst.BytesRefFSTEnum<Long> fstEnum = new util.fst.BytesRefFSTEnum<>(fst);
 		BytesRefFSTEnum<long?> fstEnum = new BytesRefFSTEnum<long?>(fst);
 
 		return new SortedDocValuesAnonymousInnerClassHelper(this, entry, docToOrd, fst, @in, firstArc, scratchArc, scratchInts, fstEnum);
@@ -503,18 +503,18 @@ namespace Lucene.Net.Codecs.Memory
 		  private MemoryDocValuesProducer.FSTEntry entry;
 		  private NumericDocValues docToOrd;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST<long?> fst;
+//ORIGINAL LINE: private util.fst.FST<long?> fst;
 		  private FST<long?> fst;
 		  private FST.BytesReader @in;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST.Arc<long?> firstArc;
+//ORIGINAL LINE: private util.fst.FST.Arc<long?> firstArc;
 		  private FST.Arc<long?> firstArc;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST.Arc<long?> scratchArc;
+//ORIGINAL LINE: private util.fst.FST.Arc<long?> scratchArc;
 		  private FST.Arc<long?> scratchArc;
 		  private IntsRef scratchInts;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.BytesRefFSTEnum<long?> fstEnum;
+//ORIGINAL LINE: private util.fst.BytesRefFSTEnum<long?> fstEnum;
 		  private BytesRefFSTEnum<long?> fstEnum;
 
 		  public SortedDocValuesAnonymousInnerClassHelper<T1, T2, T3, T4>(MemoryDocValuesProducer outerInstance, org.MemoryDocValuesProducer.FSTEntry entry, NumericDocValues docToOrd, FST<T1> fst, FST.BytesReader @in, FST.Arc<T2> firstArc, FST.Arc<T3> scratchArc, IntsRef scratchInts, BytesRefFSTEnum<T4> fstEnum)
@@ -592,7 +592,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.index.SortedSetDocValues getSortedSet(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: @Override public index.SortedSetDocValues getSortedSet(index.FieldInfo field) throws java.io.IOException
 	  public override SortedSetDocValues getSortedSet(FieldInfo field)
 	  {
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
@@ -615,33 +615,33 @@ namespace Lucene.Net.Codecs.Memory
 		  }
 		}
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.index.BinaryDocValues docToOrds = getBinary(field);
+//ORIGINAL LINE: final index.BinaryDocValues docToOrds = getBinary(field);
 		BinaryDocValues docToOrds = getBinary(field);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST<Long> fst = instance;
+//ORIGINAL LINE: final util.fst.FST<Long> fst = instance;
 		FST<long?> fst = instance;
 
 		// per-thread resources
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.BytesReader in = fst.getBytesReader();
+//ORIGINAL LINE: final util.fst.FST.BytesReader in = fst.getBytesReader();
 		FST.BytesReader @in = fst.BytesReader;
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.Arc<Long> firstArc = new org.apache.lucene.util.fst.FST.Arc<>();
+//ORIGINAL LINE: final util.fst.FST.Arc<Long> firstArc = new util.fst.FST.Arc<>();
 		FST.Arc<long?> firstArc = new FST.Arc<long?>();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.FST.Arc<Long> scratchArc = new org.apache.lucene.util.fst.FST.Arc<>();
+//ORIGINAL LINE: final util.fst.FST.Arc<Long> scratchArc = new util.fst.FST.Arc<>();
 		FST.Arc<long?> scratchArc = new FST.Arc<long?>();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.IntsRef scratchInts = new org.apache.lucene.util.IntsRef();
+//ORIGINAL LINE: final util.IntsRef scratchInts = new util.IntsRef();
 		IntsRef scratchInts = new IntsRef();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.fst.BytesRefFSTEnum<Long> fstEnum = new org.apache.lucene.util.fst.BytesRefFSTEnum<>(fst);
+//ORIGINAL LINE: final util.fst.BytesRefFSTEnum<Long> fstEnum = new util.fst.BytesRefFSTEnum<>(fst);
 		BytesRefFSTEnum<long?> fstEnum = new BytesRefFSTEnum<long?>(fst);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.util.BytesRef ref = new org.apache.lucene.util.BytesRef();
+//ORIGINAL LINE: final util.BytesRef ref = new util.BytesRef();
 		BytesRef @ref = new BytesRef();
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.store.ByteArrayDataInput input = new org.apache.lucene.store.ByteArrayDataInput();
+//ORIGINAL LINE: final store.ByteArrayDataInput input = new store.ByteArrayDataInput();
 		ByteArrayDataInput input = new ByteArrayDataInput();
 		return new SortedSetDocValuesAnonymousInnerClassHelper(this, entry, docToOrds, fst, @in, firstArc, scratchArc, scratchInts, fstEnum, @ref, input);
 	  }
@@ -653,18 +653,18 @@ namespace Lucene.Net.Codecs.Memory
 		  private MemoryDocValuesProducer.FSTEntry entry;
 		  private BinaryDocValues docToOrds;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST<long?> fst;
+//ORIGINAL LINE: private util.fst.FST<long?> fst;
 		  private FST<long?> fst;
 		  private FST.BytesReader @in;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST.Arc<long?> firstArc;
+//ORIGINAL LINE: private util.fst.FST.Arc<long?> firstArc;
 		  private FST.Arc<long?> firstArc;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.FST.Arc<long?> scratchArc;
+//ORIGINAL LINE: private util.fst.FST.Arc<long?> scratchArc;
 		  private FST.Arc<long?> scratchArc;
 		  private IntsRef scratchInts;
 //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.fst.BytesRefFSTEnum<long?> fstEnum;
+//ORIGINAL LINE: private util.fst.BytesRefFSTEnum<long?> fstEnum;
 		  private BytesRefFSTEnum<long?> fstEnum;
 		  private BytesRef @ref;
 		  private ByteArrayDataInput input;
@@ -766,7 +766,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: private org.apache.lucene.util.Bits getMissingBits(int fieldNumber, final long offset, final long length) throws java.io.IOException
+//ORIGINAL LINE: private util.Bits getMissingBits(int fieldNumber, final long offset, final long length) throws java.io.IOException
 //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
 	  private Bits getMissingBits(int fieldNumber, long offset, long length)
 	  {
@@ -799,7 +799,7 @@ namespace Lucene.Net.Codecs.Memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.util.Bits getDocsWithField(org.apache.lucene.index.FieldInfo field) throws java.io.IOException
+//ORIGINAL LINE: @Override public util.Bits getDocsWithField(index.FieldInfo field) throws java.io.IOException
 	  public override Bits getDocsWithField(FieldInfo field)
 	  {
 		switch (field.DocValuesType)
@@ -875,7 +875,7 @@ namespace Lucene.Net.Codecs.Memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.util.BytesRef next() throws java.io.IOException
+//ORIGINAL LINE: @Override public util.BytesRef next() throws java.io.IOException
 		public override BytesRef next()
 		{
 		  BytesRefFSTEnum.InputOutput<long?> io = @in.next();
@@ -898,7 +898,7 @@ namespace Lucene.Net.Codecs.Memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public SeekStatus seekCeil(org.apache.lucene.util.BytesRef text) throws java.io.IOException
+//ORIGINAL LINE: @Override public SeekStatus seekCeil(util.BytesRef text) throws java.io.IOException
 		public override SeekStatus seekCeil(BytesRef text)
 		{
 		  if (@in.seekCeil(text) == null)
@@ -918,7 +918,7 @@ namespace Lucene.Net.Codecs.Memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public boolean seekExact(org.apache.lucene.util.BytesRef text) throws java.io.IOException
+//ORIGINAL LINE: @Override public boolean seekExact(util.BytesRef text) throws java.io.IOException
 		public override bool seekExact(BytesRef text)
 		{
 		  if (@in.seekExact(text) == null)
@@ -949,7 +949,7 @@ namespace Lucene.Net.Codecs.Memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.util.BytesRef term() throws java.io.IOException
+//ORIGINAL LINE: @Override public util.BytesRef term() throws java.io.IOException
 		public override BytesRef term()
 		{
 		  return @in.current().input;
@@ -977,14 +977,14 @@ namespace Lucene.Net.Codecs.Memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.index.DocsEnum docs(org.apache.lucene.util.Bits liveDocs, org.apache.lucene.index.DocsEnum reuse, int flags) throws java.io.IOException
+//ORIGINAL LINE: @Override public index.DocsEnum docs(util.Bits liveDocs, index.DocsEnum reuse, int flags) throws java.io.IOException
 		public override DocsEnum docs(Bits liveDocs, DocsEnum reuse, int flags)
 		{
 		  throw new System.NotSupportedException();
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.index.DocsAndPositionsEnum docsAndPositions(org.apache.lucene.util.Bits liveDocs, org.apache.lucene.index.DocsAndPositionsEnum reuse, int flags) throws java.io.IOException
+//ORIGINAL LINE: @Override public index.DocsAndPositionsEnum docsAndPositions(util.Bits liveDocs, index.DocsAndPositionsEnum reuse, int flags) throws java.io.IOException
 		public override DocsAndPositionsEnum docsAndPositions(Bits liveDocs, DocsAndPositionsEnum reuse, int flags)
 		{
 		  throw new System.NotSupportedException();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/af4d125b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index f45bc24..b655f4e 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -1,56 +1,56 @@
-using System;
+/*
+ * 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.Diagnostics;
 using System.Collections.Generic;
+using Lucene.Net.Util.Packed;
 
-namespace org.apache.lucene.codecs.memory
+namespace Lucene.Net.Codecs.Memory
 {
 
-	/*
-	 * 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 DocsAndPositionsEnum = org.apache.lucene.index.DocsAndPositionsEnum;
-	using DocsEnum = org.apache.lucene.index.DocsEnum;
-	using IndexOptions = org.apache.lucene.index.FieldInfo.IndexOptions;
-	using FieldInfo = org.apache.lucene.index.FieldInfo;
-	using FieldInfos = org.apache.lucene.index.FieldInfos;
-	using IndexFileNames = org.apache.lucene.index.IndexFileNames;
-	using SegmentReadState = org.apache.lucene.index.SegmentReadState;
-	using SegmentWriteState = org.apache.lucene.index.SegmentWriteState;
-	using Terms = org.apache.lucene.index.Terms;
-	using TermsEnum = org.apache.lucene.index.TermsEnum;
-	using ByteArrayDataInput = org.apache.lucene.store.ByteArrayDataInput;
-	using ChecksumIndexInput = org.apache.lucene.store.ChecksumIndexInput;
-	using IOContext = org.apache.lucene.store.IOContext;
-	using IndexInput = org.apache.lucene.store.IndexInput;
-	using IndexOutput = org.apache.lucene.store.IndexOutput;
-	using RAMOutputStream = org.apache.lucene.store.RAMOutputStream;
-	using ArrayUtil = org.apache.lucene.util.ArrayUtil;
-	using Bits = org.apache.lucene.util.Bits;
-	using BytesRef = org.apache.lucene.util.BytesRef;
-	using IOUtils = org.apache.lucene.util.IOUtils;
-	using IntsRef = org.apache.lucene.util.IntsRef;
-	using RamUsageEstimator = org.apache.lucene.util.RamUsageEstimator;
-	using Builder = org.apache.lucene.util.fst.Builder;
-	using ByteSequenceOutputs = org.apache.lucene.util.fst.ByteSequenceOutputs;
-	using BytesRefFSTEnum = org.apache.lucene.util.fst.BytesRefFSTEnum;
-	using FST = org.apache.lucene.util.fst.FST;
-	using Util = org.apache.lucene.util.fst.Util;
-	using PackedInts = org.apache.lucene.util.packed.PackedInts;
+	using DocsAndPositionsEnum = Index.DocsAndPositionsEnum;
+	using DocsEnum = Index.DocsEnum;
+	using IndexOptions = Index.FieldInfo.IndexOptions;
+	using FieldInfo = Index.FieldInfo;
+	using FieldInfos = Index.FieldInfos;
+	using IndexFileNames = Index.IndexFileNames;
+	using SegmentReadState = Index.SegmentReadState;
+	using SegmentWriteState = Index.SegmentWriteState;
+	using Terms = Index.Terms;
+	using TermsEnum = Index.TermsEnum;
+	using ByteArrayDataInput = Store.ByteArrayDataInput;
+	using ChecksumIndexInput = Store.ChecksumIndexInput;
+	using IOContext = Store.IOContext;
+	using IndexInput = Store.IndexInput;
+	using IndexOutput = Store.IndexOutput;
+	using RAMOutputStream = Store.RAMOutputStream;
+	using ArrayUtil = Util.ArrayUtil;
+	using Bits = Util.Bits;
+	using BytesRef = Util.BytesRef;
+	using IOUtils = Util.IOUtils;
+	using IntsRef = Util.IntsRef;
+	using RamUsageEstimator = Util.RamUsageEstimator;
+	using Builder = Util.Fst.Builder;
+	using ByteSequenceOutputs = Util.Fst.ByteSequenceOutputs;
+	using BytesRefFSTEnum = Util.Fst.BytesRefFSTEnum;
+	using FST = Util.Fst.FST;
+	using Util = Util.Fst.Util;
+	using PackedInts = Util.packed.PackedInts;
 
 	// TODO: would be nice to somehow allow this to act like
 	// InstantiatedIndex, by never writing to disk; ie you write
@@ -184,7 +184,7 @@ namespace org.apache.lucene.codecs.memory
 		  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void addPosition(int pos, org.apache.lucene.util.BytesRef payload, int startOffset, int endOffset) throws java.io.IOException
+//ORIGINAL LINE: @Override public void addPosition(int pos, util.BytesRef payload, int startOffset, int endOffset) throws java.io.IOException
 		  public override void addPosition(int pos, BytesRef payload, int startOffset, int endOffset)
 		  {
 			Debug.Assert(payload == null || outerInstance.field.hasPayloads());
@@ -274,7 +274,7 @@ namespace org.apache.lucene.codecs.memory
 		internal readonly IntsRef scratchIntsRef = new IntsRef();
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public void finishTerm(org.apache.lucene.util.BytesRef text, org.apache.lucene.codecs.TermStats stats) throws java.io.IOException
+//ORIGINAL LINE: @Override public void finishTerm(util.BytesRef text, codecs.TermStats stats) throws java.io.IOException
 		public override void finishTerm(BytesRef text, TermStats stats)
 		{
 
@@ -348,15 +348,15 @@ namespace org.apache.lucene.codecs.memory
 	  private const int VERSION_CURRENT = VERSION_START;
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.codecs.FieldsConsumer fieldsConsumer(org.apache.lucene.index.SegmentWriteState state) throws java.io.IOException
+//ORIGINAL LINE: @Override public codecs.FieldsConsumer fieldsConsumer(index.SegmentWriteState state) throws java.io.IOException
 	  public override FieldsConsumer fieldsConsumer(SegmentWriteState state)
 	  {
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final String fileName = org.apache.lucene.index.IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
+//ORIGINAL LINE: final String fileName = index.IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
 		string fileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.store.IndexOutput out = state.directory.createOutput(fileName, state.context);
+//ORIGINAL LINE: final store.IndexOutput out = state.directory.createOutput(fileName, state.context);
 		IndexOutput @out = state.directory.createOutput(fileName, state.context);
 		bool success = false;
 		try
@@ -858,7 +858,7 @@ namespace org.apache.lucene.codecs.memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public boolean seekExact(org.apache.lucene.util.BytesRef text) throws java.io.IOException
+//ORIGINAL LINE: @Override public boolean seekExact(util.BytesRef text) throws java.io.IOException
 		public override bool seekExact(BytesRef text)
 		{
 		  //System.out.println("te.seekExact text=" + field.name + ":" + text.utf8ToString() + " this=" + this);
@@ -868,7 +868,7 @@ namespace org.apache.lucene.codecs.memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public SeekStatus seekCeil(org.apache.lucene.util.BytesRef text) throws java.io.IOException
+//ORIGINAL LINE: @Override public SeekStatus seekCeil(util.BytesRef text) throws java.io.IOException
 		public override SeekStatus seekCeil(BytesRef text)
 		{
 		  //System.out.println("te.seek text=" + field.name + ":" + text.utf8ToString() + " this=" + this);
@@ -952,7 +952,7 @@ namespace org.apache.lucene.codecs.memory
 		}
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.util.BytesRef next() throws java.io.IOException
+//ORIGINAL LINE: @Override public util.BytesRef next() throws java.io.IOException
 		public override BytesRef next()
 		{
 		  //System.out.println("te.next");
@@ -1012,7 +1012,7 @@ namespace org.apache.lucene.codecs.memory
 		internal readonly FieldInfo field;
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: public TermsReader(org.apache.lucene.index.FieldInfos fieldInfos, org.apache.lucene.store.IndexInput in, int termCount) throws java.io.IOException
+//ORIGINAL LINE: public TermsReader(index.FieldInfos fieldInfos, store.IndexInput in, int termCount) throws java.io.IOException
 		public TermsReader(FieldInfos fieldInfos, IndexInput @in, int termCount)
 		{
 		  this.termCount = termCount;
@@ -1103,14 +1103,14 @@ namespace org.apache.lucene.codecs.memory
 	  }
 
 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
-//ORIGINAL LINE: @Override public org.apache.lucene.codecs.FieldsProducer fieldsProducer(org.apache.lucene.index.SegmentReadState state) throws java.io.IOException
+//ORIGINAL LINE: @Override public codecs.FieldsProducer fieldsProducer(index.SegmentReadState state) throws java.io.IOException
 	  public override FieldsProducer fieldsProducer(SegmentReadState state)
 	  {
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final String fileName = org.apache.lucene.index.IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
+//ORIGINAL LINE: final String fileName = index.IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
 		string fileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-//ORIGINAL LINE: final org.apache.lucene.store.ChecksumIndexInput in = state.directory.openChecksumInput(fileName, org.apache.lucene.store.IOContext.READONCE);
+//ORIGINAL LINE: final store.ChecksumIndexInput in = state.directory.openChecksumInput(fileName, store.IOContext.READONCE);
 		ChecksumIndexInput @in = state.directory.openChecksumInput(fileName, IOContext.READONCE);
 
 //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':


Mime
View raw message