Lucene.Net.Misc: Renamed all type-derived classes and interfaces from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/89e3de62 Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/89e3de62 Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/89e3de62 Branch: refs/heads/api-work Commit: 89e3de620d92acf9ceb48a7d98f82a0edcf473e9 Parents: c348531 Author: Shad Storhaug <[email protected]> Authored: Wed Feb 8 02:55:53 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Wed Feb 8 21:08:23 2017 +0700 ---------------------------------------------------------------------- src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs | 2 +- .../Util/Fst/UpToTwoPositiveIntOutputs.cs | 48 +++++++++++--------- .../Util/Fst/TestFSTsMisc.cs | 10 ++-- 3 files changed, 32 insertions(+), 28 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/89e3de62/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs index 5bc303b..27ca0f3 100644 --- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs +++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs @@ -42,7 +42,7 @@ namespace Lucene.Net.Util.Fst /// how the FST maps a single input to multiple outputs (e.g. you /// cannot pass a List<Object> to <see cref="Builder{T}.Add(Int32sRef, T)"/>). If /// your outputs are longs, and you need at most 2, then use - /// <see cref="UpToTwoPositiveIntOutputs"/> instead since it stores + /// <see cref="UpToTwoPositiveInt64Outputs"/> instead since it stores /// the outputs more compactly (by stealing a bit from each /// long value). /// http://git-wip-us.apache.org/repos/asf/lucenenet/blob/89e3de62/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs index 0a21fb2..d4442ee 100644 --- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs +++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs @@ -34,7 +34,7 @@ namespace Lucene.Net.Util.Fst /// <para>NOTE: the only way to create a TwoLongs output is to /// add the same input to the FST twice in a row. This is /// how the FST maps a single input to two outputs (e.g. you - /// cannot pass a <see cref="TwoLongs"/> to <see cref="Builder{T}.Add(Int32sRef, T)"/>. If you + /// cannot pass a <see cref="TwoInt64s"/> to <see cref="Builder{T}.Add(Int32sRef, T)"/>. If you /// need more than two then use <see cref="ListOfOutputs{T}"/>, but if /// you only have at most 2 then this implementation will /// require fewer bytes as it steals one bit from each long @@ -43,16 +43,20 @@ namespace Lucene.Net.Util.Fst /// </para> /// <para>NOTE: the resulting FST is not guaranteed to be minimal! /// See <see cref="Builder{T}"/>. - /// - /// @lucene.experimental /// </para> + /// <para> + /// NOTE: This was UpToTwoPositiveIntOutputs in Lucene - the data type (int) was wrong there - it should have been long + /// </para> + /// @lucene.experimental /// </summary> - public sealed class UpToTwoPositiveIntOutputs : Outputs<object> + public sealed class UpToTwoPositiveInt64Outputs : Outputs<object> { - /// <summary> - /// Holds two long outputs. </summary> - public sealed class TwoLongs + /// Holds two long outputs. + /// <para/> + /// NOTE: This was TwoLongs in Lucene + /// </summary> + public sealed class TwoInt64s { public long First { @@ -66,7 +70,7 @@ namespace Lucene.Net.Util.Fst } private readonly long second; - public TwoLongs(long first, long second) + public TwoInt64s(long first, long second) { this.first = first; this.second = second; @@ -81,9 +85,9 @@ namespace Lucene.Net.Util.Fst public override bool Equals(object other) { - if (other is TwoLongs) + if (other is TwoInt64s) { - TwoLongs other2 = (TwoLongs)other; + TwoInt64s other2 = (TwoInt64s)other; return first == other2.first && second == other2.second; } else @@ -102,15 +106,15 @@ namespace Lucene.Net.Util.Fst private readonly bool doShare; - private static readonly UpToTwoPositiveIntOutputs singletonShare = new UpToTwoPositiveIntOutputs(true); - private static readonly UpToTwoPositiveIntOutputs singletonNoShare = new UpToTwoPositiveIntOutputs(false); + private static readonly UpToTwoPositiveInt64Outputs singletonShare = new UpToTwoPositiveInt64Outputs(true); + private static readonly UpToTwoPositiveInt64Outputs singletonNoShare = new UpToTwoPositiveInt64Outputs(false); - private UpToTwoPositiveIntOutputs(bool doShare) + private UpToTwoPositiveInt64Outputs(bool doShare) { this.doShare = doShare; } - public static UpToTwoPositiveIntOutputs GetSingleton(bool doShare) + public static UpToTwoPositiveInt64Outputs GetSingleton(bool doShare) { return doShare ? singletonShare : singletonNoShare; } @@ -127,9 +131,9 @@ namespace Lucene.Net.Util.Fst } } - public TwoLongs Get(long first, long second) + public TwoInt64s Get(long first, long second) { - return new TwoLongs(first, second); + return new TwoInt64s(first, second); } public override object Common(object output1, object output2) @@ -203,9 +207,9 @@ namespace Lucene.Net.Util.Fst } else { - TwoLongs output3 = (TwoLongs)output; + TwoInt64s output3 = (TwoInt64s)output; long v = prefix2.Value; - return new TwoLongs(output3.First + v, output3.Second + v); + return new TwoInt64s(output3.First + v, output3.Second + v); } } @@ -219,7 +223,7 @@ namespace Lucene.Net.Util.Fst } else { - TwoLongs output3 = (TwoLongs)output; + TwoInt64s output3 = (TwoInt64s)output; @out.WriteVInt64((output3.First << 1) | 1); @out.WriteVInt64(output3.Second); } @@ -246,7 +250,7 @@ namespace Lucene.Net.Util.Fst // two longs long first = (long)((ulong)code >> 1); long second = @in.ReadVInt64(); - return new TwoLongs(first, second); + return new TwoInt64s(first, second); } } @@ -266,7 +270,7 @@ namespace Lucene.Net.Util.Fst Debug.Assert(o is long?); return Valid((long?)o); } - else if (o is TwoLongs) + else if (o is TwoInt64s) { return true; } @@ -293,7 +297,7 @@ namespace Lucene.Net.Util.Fst { Debug.Assert(Valid(first, false)); Debug.Assert(Valid(second, false)); - return new TwoLongs(((long?)first).GetValueOrDefault(), ((long?)second).GetValueOrDefault()); + return new TwoInt64s(((long?)first).GetValueOrDefault(), ((long?)second).GetValueOrDefault()); } } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/89e3de62/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs index 7ad22ef..304f11d 100644 --- a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs +++ b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs @@ -67,7 +67,7 @@ namespace Lucene.Net.Util.Fst { Console.WriteLine("TEST: now test UpToTwoPositiveIntOutputs"); } - UpToTwoPositiveIntOutputs outputs = UpToTwoPositiveIntOutputs.GetSingleton(true); + UpToTwoPositiveInt64Outputs outputs = UpToTwoPositiveInt64Outputs.GetSingleton(true); List<Lucene.Net.Util.Fst.FSTTester<object>.InputOutput<object>> pairs = new List<Lucene.Net.Util.Fst.FSTTester<object>.InputOutput<object>>(terms.Length); long lastOutput = 0; for (int idx = 0; idx < terms.Length; idx++) @@ -153,16 +153,16 @@ namespace Lucene.Net.Util.Fst protected internal override bool OutputsEqual(T output1, T output2) { - if (output1 is UpToTwoPositiveIntOutputs.TwoLongs && output2 is IEnumerable<long>) + if (output1 is UpToTwoPositiveInt64Outputs.TwoInt64s && output2 is IEnumerable<long>) { - UpToTwoPositiveIntOutputs.TwoLongs twoLongs1 = output1 as UpToTwoPositiveIntOutputs.TwoLongs; + UpToTwoPositiveInt64Outputs.TwoInt64s twoLongs1 = output1 as UpToTwoPositiveInt64Outputs.TwoInt64s; long[] list2 = (output2 as IEnumerable<long>).ToArray(); return (new long[] { twoLongs1.First, twoLongs1.Second }).SequenceEqual(list2); } - else if (output2 is UpToTwoPositiveIntOutputs.TwoLongs && output1 is IEnumerable<long>) + else if (output2 is UpToTwoPositiveInt64Outputs.TwoInt64s && output1 is IEnumerable<long>) { long[] list1 = (output1 as IEnumerable<long>).ToArray(); - UpToTwoPositiveIntOutputs.TwoLongs twoLongs2 = output2 as UpToTwoPositiveIntOutputs.TwoLongs; + UpToTwoPositiveInt64Outputs.TwoInt64s twoLongs2 = output2 as UpToTwoPositiveInt64Outputs.TwoInt64s; return (new long[] { twoLongs2.First, twoLongs2.Second }).SequenceEqual(list1); }
