You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/03/06 14:39:57 UTC
[04/12] lucenenet git commit:
Lucene.Net.QueryParser.Simple.SimpleQueryParser: de-nested Operator [Flags]
enum from the SimpleQueryParser type
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 <sh...@shadstorhaug.com>
Authored: Mon Mar 6 10:30:46 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
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
}
}
}