Lucene.Net.QueryParser.Simple.SimpleQueryParser: de-nested Operator [Flags] enum from the SimpleQueryParser type
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8e6439dd Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8e6439dd Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8e6439dd Branch: refs/heads/api-work Commit: 8e6439dd55b897880c78eafde06a61858db8d1a7 Parents: a6d69ac Author: Shad Storhaug <[email protected]> Authored: Mon Mar 6 10:30:46 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Mon Mar 6 18:08:06 2017 +0700 ---------------------------------------------------------------------- .../Simple/SimpleQueryParser.cs | 59 ++++++++++---------- .../Simple/TestSimpleQueryParser.cs | 42 +++++++------- 2 files changed, 50 insertions(+), 51 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8e6439dd/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs index fab1dce..01af234 100644 --- a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs +++ b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs @@ -28,6 +28,33 @@ namespace Lucene.Net.QueryParsers.Simple * limitations under the License. */ + // LUCENENET specific - converted constants from SimpleQueryParser + // into a flags enum. + [Flags] + public enum Operator + { + /// <summary>Enables <c>AND</c> operator (+)</summary> + AND_OPERATOR = 1 << 0, + /// <summary>Enables <c>NOT</c> operator (-)</summary> + NOT_OPERATOR = 1 << 1, + /// <summary>Enables <c>OR</c> operator (|)</summary> + OR_OPERATOR = 1 << 2, + /// <summary>Enables <c>PREFIX</c> operator (*)</summary> + PREFIX_OPERATOR = 1 << 3, + /// <summary>Enables <c>PHRASE</c> operator (")</summary> + PHRASE_OPERATOR = 1 << 4, + /// <summary>Enables <c>PRECEDENCE</c> operators: <c>(</c> and <c>)</c></summary> + PRECEDENCE_OPERATORS = 1 << 5, + /// <summary>Enables <c>ESCAPE</c> operator (\)</summary> + ESCAPE_OPERATOR = 1 << 6, + /// <summary>Enables <c>WHITESPACE</c> operators: ' ' '\n' '\r' '\t'</summary> + WHITESPACE_OPERATOR = 1 << 7, + /// <summary>Enables <c>FUZZY</c> operators: (~) on single terms</summary> + FUZZY_OPERATOR = 1 << 8, + /// <summary>Enables <c>NEAR</c> operators: (~) on phrases</summary> + NEAR_OPERATOR = 1 << 9 + } + /// <summary> /// <see cref="SimpleQueryParser"/> is used to parse human readable query syntax. /// <para/> @@ -95,37 +122,11 @@ namespace Lucene.Net.QueryParsers.Simple /// <summary>Map of fields to query against with their weights</summary> protected readonly IDictionary<string, float> m_weights; - // LUCENENET specific - Made the int operator constants into a [Flags] enum - // to make them easier to pass in .NET. + // LUCENENET specific - made flags into their own [Flags] enum named Operator and de-nested from this type /// <summary>flags to the parser (to turn features on/off)</summary> protected readonly Operator m_flags; - [Flags] - public enum Operator : int - { - /// <summary>Enables <c>AND</c> operator (+)</summary> - AND_OPERATOR = 1 << 0, - /// <summary>Enables <c>NOT</c> operator (-)</summary> - NOT_OPERATOR = 1 << 1, - /// <summary>Enables <c>OR</c> operator (|)</summary> - OR_OPERATOR = 1 << 2, - /// <summary>Enables <c>PREFIX</c> operator (*)</summary> - PREFIX_OPERATOR = 1 << 3, - /// <summary>Enables <c>PHRASE</c> operator (")</summary> - PHRASE_OPERATOR = 1 << 4, - /// <summary>Enables <c>PRECEDENCE</c> operators: <c>(</c> and <c>)</c></summary> - PRECEDENCE_OPERATORS = 1 << 5, - /// <summary>Enables <c>ESCAPE</c> operator (\)</summary> - ESCAPE_OPERATOR = 1 << 6, - /// <summary>Enables <c>WHITESPACE</c> operators: ' ' '\n' '\r' '\t'</summary> - WHITESPACE_OPERATOR = 1 << 7, - /// <summary>Enables <c>FUZZY</c> operators: (~) on single terms</summary> - FUZZY_OPERATOR = 1 << 8, - /// <summary>Enables <c>NEAR</c> operators: (~) on phrases</summary> - NEAR_OPERATOR = 1 << 9 - } - private Occur defaultOperator = Occur.SHOULD; /// <summary>Creates a new parser searching over a single field.</summary> @@ -136,9 +137,7 @@ namespace Lucene.Net.QueryParsers.Simple /// <summary>Creates a new parser searching over multiple fields with different weights.</summary> public SimpleQueryParser(Analyzer analyzer, IDictionary<string, float> weights) - // LUCENENET HACK: There doesn't seem to be a way to cast -1 to Operator directly - // like you can with a number that exists in the Enum, so parsing instead. - : this(analyzer, weights, (Operator)Enum.Parse(typeof(Operator), "-1")) + : this(analyzer, weights, (Operator)(-1)) { } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8e6439dd/src/Lucene.Net.Tests.QueryParser/Simple/TestSimpleQueryParser.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests.QueryParser/Simple/TestSimpleQueryParser.cs b/src/Lucene.Net.Tests.QueryParser/Simple/TestSimpleQueryParser.cs index 0cd23ec..2aafa22 100644 --- a/src/Lucene.Net.Tests.QueryParser/Simple/TestSimpleQueryParser.cs +++ b/src/Lucene.Net.Tests.QueryParser/Simple/TestSimpleQueryParser.cs @@ -54,7 +54,7 @@ namespace Lucene.Net.QueryParsers.Simple /// <param name="text"></param> /// <param name="flags"></param> /// <returns></returns> - private Query Parse(string text, SimpleQueryParser.Operator flags) + private Query Parse(string text, Operator flags) { Analyzer analyzer = new MockAnalyzer(Random()); SimpleQueryParser parser = new SimpleQueryParser(analyzer, new HashMap<string, float>() { { "field", 1f } }, flags); @@ -591,7 +591,7 @@ namespace Lucene.Net.QueryParsers.Simple } /** helper to parse a query with keyword analyzer across "field" */ - private Query ParseKeyword(string text, SimpleQueryParser.Operator flags) + private Query ParseKeyword(string text, Operator flags) { Analyzer analyzer = new MockAnalyzer(Random(), MockTokenizer.KEYWORD, false); SimpleQueryParser parser = new SimpleQueryParser(analyzer, @@ -605,7 +605,7 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisablePhrase() { Query expected = new TermQuery(new Term("field", "\"test\"")); - assertEquals(expected, ParseKeyword("\"test\"", ~SimpleQueryParser.Operator.PHRASE_OPERATOR)); + assertEquals(expected, ParseKeyword("\"test\"", ~Operator.PHRASE_OPERATOR)); } /** test the ability to enable/disable prefix operator */ @@ -613,7 +613,7 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisablePrefix() { Query expected = new TermQuery(new Term("field", "test*")); - assertEquals(expected, ParseKeyword("test*", ~SimpleQueryParser.Operator.PREFIX_OPERATOR)); + assertEquals(expected, ParseKeyword("test*", ~Operator.PREFIX_OPERATOR)); } /** test the ability to enable/disable AND operator */ @@ -621,9 +621,9 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisableAND() { Query expected = new TermQuery(new Term("field", "foo+bar")); - assertEquals(expected, ParseKeyword("foo+bar", ~SimpleQueryParser.Operator.AND_OPERATOR)); + assertEquals(expected, ParseKeyword("foo+bar", ~Operator.AND_OPERATOR)); expected = new TermQuery(new Term("field", "+foo+bar")); - assertEquals(expected, ParseKeyword("+foo+bar", ~SimpleQueryParser.Operator.AND_OPERATOR)); + assertEquals(expected, ParseKeyword("+foo+bar", ~Operator.AND_OPERATOR)); } /** test the ability to enable/disable OR operator */ @@ -631,9 +631,9 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisableOR() { Query expected = new TermQuery(new Term("field", "foo|bar")); - assertEquals(expected, ParseKeyword("foo|bar", ~SimpleQueryParser.Operator.OR_OPERATOR)); + assertEquals(expected, ParseKeyword("foo|bar", ~Operator.OR_OPERATOR)); expected = new TermQuery(new Term("field", "|foo|bar")); - assertEquals(expected, ParseKeyword("|foo|bar", ~SimpleQueryParser.Operator.OR_OPERATOR)); + assertEquals(expected, ParseKeyword("|foo|bar", ~Operator.OR_OPERATOR)); } /** test the ability to enable/disable NOT operator */ @@ -641,7 +641,7 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisableNOT() { Query expected = new TermQuery(new Term("field", "-foo")); - assertEquals(expected, ParseKeyword("-foo", ~SimpleQueryParser.Operator.NOT_OPERATOR)); + assertEquals(expected, ParseKeyword("-foo", ~Operator.NOT_OPERATOR)); } /** test the ability to enable/disable precedence operators */ @@ -649,9 +649,9 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisablePrecedence() { Query expected = new TermQuery(new Term("field", "(foo)")); - assertEquals(expected, ParseKeyword("(foo)", ~SimpleQueryParser.Operator.PRECEDENCE_OPERATORS)); + assertEquals(expected, ParseKeyword("(foo)", ~Operator.PRECEDENCE_OPERATORS)); expected = new TermQuery(new Term("field", ")foo(")); - assertEquals(expected, ParseKeyword(")foo(", ~SimpleQueryParser.Operator.PRECEDENCE_OPERATORS)); + assertEquals(expected, ParseKeyword(")foo(", ~Operator.PRECEDENCE_OPERATORS)); } /** test the ability to enable/disable escape operators */ @@ -659,27 +659,27 @@ namespace Lucene.Net.QueryParsers.Simple public virtual void TestDisableEscape() { Query expected = new TermQuery(new Term("field", "foo\\bar")); - assertEquals(expected, ParseKeyword("foo\\bar", ~SimpleQueryParser.Operator.ESCAPE_OPERATOR)); - assertEquals(expected, ParseKeyword("(foo\\bar)", ~SimpleQueryParser.Operator.ESCAPE_OPERATOR)); - assertEquals(expected, ParseKeyword("\"foo\\bar\"", ~SimpleQueryParser.Operator.ESCAPE_OPERATOR)); + assertEquals(expected, ParseKeyword("foo\\bar", ~Operator.ESCAPE_OPERATOR)); + assertEquals(expected, ParseKeyword("(foo\\bar)", ~Operator.ESCAPE_OPERATOR)); + assertEquals(expected, ParseKeyword("\"foo\\bar\"", ~Operator.ESCAPE_OPERATOR)); } [Test] public virtual void TestDisableWhitespace() { Query expected = new TermQuery(new Term("field", "foo foo")); - assertEquals(expected, ParseKeyword("foo foo", ~SimpleQueryParser.Operator.WHITESPACE_OPERATOR)); + assertEquals(expected, ParseKeyword("foo foo", ~Operator.WHITESPACE_OPERATOR)); expected = new TermQuery(new Term("field", " foo foo\n ")); - assertEquals(expected, ParseKeyword(" foo foo\n ", ~SimpleQueryParser.Operator.WHITESPACE_OPERATOR)); + assertEquals(expected, ParseKeyword(" foo foo\n ", ~Operator.WHITESPACE_OPERATOR)); expected = new TermQuery(new Term("field", "\t\tfoo foo foo")); - assertEquals(expected, ParseKeyword("\t\tfoo foo foo", ~SimpleQueryParser.Operator.WHITESPACE_OPERATOR)); + assertEquals(expected, ParseKeyword("\t\tfoo foo foo", ~Operator.WHITESPACE_OPERATOR)); } [Test] public virtual void TestDisableFuzziness() { Query expected = new TermQuery(new Term("field", "foo~1")); - assertEquals(expected, ParseKeyword("foo~1", ~SimpleQueryParser.Operator.FUZZY_OPERATOR)); + assertEquals(expected, ParseKeyword("foo~1", ~Operator.FUZZY_OPERATOR)); } [Test] @@ -692,7 +692,7 @@ namespace Lucene.Net.QueryParsers.Simple BooleanQuery expected = new BooleanQuery(); expected.Add(expectedPhrase, Occur.MUST); expected.Add(new TermQuery(new Term("field", "~2")), Occur.MUST); - assertEquals(expected, Parse("\"foo bar\"~2", ~SimpleQueryParser.Operator.NEAR_OPERATOR)); + assertEquals(expected, Parse("\"foo bar\"~2", ~Operator.NEAR_OPERATOR)); } // we aren't supposed to barf on any input... @@ -703,7 +703,7 @@ namespace Lucene.Net.QueryParsers.Simple { string query = TestUtil.RandomUnicodeString(Random()); Parse(query); // no exception - ParseKeyword(query, (SimpleQueryParser.Operator)TestUtil.NextInt(Random(), 0, 1024)); // no exception + ParseKeyword(query, (Operator)TestUtil.NextInt(Random(), 0, 1024)); // no exception } } @@ -721,7 +721,7 @@ namespace Lucene.Net.QueryParsers.Simple sb.append(chars[Random().Next(chars.Length)]); } Parse(sb.toString()); // no exception - ParseKeyword(sb.toString(), (SimpleQueryParser.Operator)TestUtil.NextInt(Random(), 0, 1024)); // no exception + ParseKeyword(sb.toString(), (Operator)TestUtil.NextInt(Random(), 0, 1024)); // no exception } } }
