lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [16/58] lucenenet git commit: QueryParser.Flexible Refactor: Properties
Date Tue, 06 Dec 2016 15:11:51 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
index 5a41c35..589a968 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
@@ -32,34 +32,34 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         private static readonly string[] escapableWordTokens = { "AND", "OR", "NOT",
             "TO", "WITHIN", "SENTENCE", "PARAGRAPH", "INORDER" };
 
-        // LUCENENET specific overload for string
-        private static string EscapeChar(string str, CultureInfo locale)
-        {
-            if (str == null || str.Length == 0)
-                return str;
-
-            string buffer = str;
-
-            // regular escapable Char for terms
-            for (int i = 0; i < escapableTermChars.Length; i++)
-            {
-                buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
-                    "\\", locale);
-            }
-
-            // First Character of a term as more escaping chars
-            for (int i = 0; i < escapableTermExtraFirstChars.Length; i++)
-            {
-                if (buffer[0] == escapableTermExtraFirstChars[i][0])
-                {
-                    buffer = "\\" + buffer[0]
-                        + buffer.Substring(1, buffer.Length - 1);
-                    break;
-                }
-            }
-
-            return buffer;
-        }
+        //// LUCENENET specific overload for string
+        //private static string EscapeChar(string str, CultureInfo locale)
+        //{
+        //    if (str == null || str.Length == 0)
+        //        return str;
+
+        //    string buffer = str;
+
+        //    // regular escapable Char for terms
+        //    for (int i = 0; i < escapableTermChars.Length; i++)
+        //    {
+        //        buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
+        //            "\\", locale);
+        //    }
+
+        //    // First Character of a term as more escaping chars
+        //    for (int i = 0; i < escapableTermExtraFirstChars.Length; i++)
+        //    {
+        //        if (buffer[0] == escapableTermExtraFirstChars[i][0])
+        //        {
+        //            buffer = "\\" + buffer[0]
+        //                + buffer.Substring(1, buffer.Length - 1);
+        //            break;
+        //        }
+        //    }
+
+        //    return buffer;
+        //}
 
         private static ICharSequence EscapeChar(ICharSequence str, CultureInfo locale)
         {
@@ -89,21 +89,21 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return buffer;
         }
 
-        // LUCENENET specific overload for string
-        private string EscapeQuoted(string str, CultureInfo locale)
-        {
-            if (str == null || str.Length == 0)
-                return str;
+        //// LUCENENET specific overload for string
+        //private string EscapeQuoted(string str, CultureInfo locale)
+        //{
+        //    if (str == null || str.Length == 0)
+        //        return str;
 
-            string buffer = str;
+        //    string buffer = str;
 
-            for (int i = 0; i < escapableQuotedChars.Length; i++)
-            {
-                buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
-                    "\\", locale);
-            }
-            return buffer;
-        }
+        //    for (int i = 0; i < escapableQuotedChars.Length; i++)
+        //    {
+        //        buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
+        //            "\\", locale);
+        //    }
+        //    return buffer;
+        //}
 
         private ICharSequence EscapeQuoted(ICharSequence str, CultureInfo locale)
         {
@@ -120,24 +120,24 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return buffer;
         }
 
-        // LUCENENET specific overload for string
-        private static string EscapeTerm(string term, CultureInfo locale)
-        {
-            if (term == null)
-                return term;
-
-            // Escape single Chars
-            term = EscapeChar(term, locale);
-            term = EscapeWhiteChar(term, locale);
-
-            // Escape Parser Words
-            for (int i = 0; i < escapableWordTokens.Length; i++)
-            {
-                if (escapableWordTokens[i].Equals(term.ToString(), StringComparison.OrdinalIgnoreCase))
-                    return "\\" + term;
-            }
-            return term;
-        }
+        //// LUCENENET specific overload for string
+        //private static string EscapeTerm(string term, CultureInfo locale)
+        //{
+        //    if (term == null)
+        //        return term;
+
+        //    // Escape single Chars
+        //    term = EscapeChar(term, locale);
+        //    term = EscapeWhiteChar(term, locale);
+
+        //    // Escape Parser Words
+        //    for (int i = 0; i < escapableWordTokens.Length; i++)
+        //    {
+        //        if (escapableWordTokens[i].Equals(term.ToString(), StringComparison.OrdinalIgnoreCase))
+        //            return "\\" + term;
+        //    }
+        //    return term;
+        //}
 
         private static ICharSequence EscapeTerm(ICharSequence term, CultureInfo locale)
         {
@@ -169,7 +169,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
          * @return the new String
          */
         // LUCENENET specific overload for string
-        private static string ReplaceIgnoreCase(string @string,
+        private static ICharSequence ReplaceIgnoreCase(ICharSequence @string,
             string sequence1, string escapeChar, CultureInfo locale)
         {
             if (escapeChar == null || sequence1 == null || @string == null)
@@ -188,7 +188,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                     result2.Append(@string[i]);
                     result2.Append(escapeChar);
                 }
-                return result2.ToString();
+                return result2.ToString().ToCharSequence();
             }
 
             // normal case
@@ -227,47 +227,49 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                     start = firstIndex + 1;
                 }
             }
+            
+
             if (result.Length == 0 && copyStart == 0)
                 return @string;
             result.Append(@string.ToString().Substring(copyStart));
-            return result.ToString();
+            return result.ToString().ToCharSequence();
         }
 
-        private static ICharSequence ReplaceIgnoreCase(ICharSequence @string,
-           string sequence1, string escapeChar, CultureInfo locale)
-        {
-            if (escapeChar == null || sequence1 == null || @string == null)
-                throw new NullReferenceException(); // LUCNENET TODO: ArgumentException...
-
-            return new StringCharSequenceWrapper(
-                ReplaceIgnoreCase(@string.ToString(), sequence1, escapeChar, locale));
-        }
-
-        /**
-         * escape all tokens that are part of the parser syntax on a given string
-         * 
-         * @param str
-         *          string to get replaced
-         * @param locale
-         *          locale to be used when performing string compares
-         * @return the new String
-         */
-        // LUCENENET specific overload for string
-        private static string EscapeWhiteChar(string str,
-            CultureInfo locale)
-        {
-            if (str == null || str.Length == 0)
-                return str;
-
-            string buffer = str;
-
-            for (int i = 0; i < escapableWhiteChars.Length; i++)
-            {
-                buffer = ReplaceIgnoreCase(buffer, escapableWhiteChars[i].ToLower(locale),
-                    "\\", locale);
-            }
-            return buffer;
-        }
+        //private static ICharSequence ReplaceIgnoreCase(ICharSequence @string,
+        //   string sequence1, string escapeChar, CultureInfo locale)
+        //{
+        //    if (escapeChar == null || sequence1 == null || @string == null)
+        //        throw new NullReferenceException(); // LUCNENET TODO: ArgumentException...
+
+        //    return new StringCharSequenceWrapper(
+        //        ReplaceIgnoreCase(@string.ToString(), sequence1, escapeChar, locale));
+        //}
+
+        ///**
+        // * escape all tokens that are part of the parser syntax on a given string
+        // * 
+        // * @param str
+        // *          string to get replaced
+        // * @param locale
+        // *          locale to be used when performing string compares
+        // * @return the new String
+        // */
+        //// LUCENENET specific overload for string
+        //private static string EscapeWhiteChar(string str,
+        //    CultureInfo locale)
+        //{
+        //    if (str == null || str.Length == 0)
+        //        return str;
+
+        //    string buffer = str;
+
+        //    for (int i = 0; i < escapableWhiteChars.Length; i++)
+        //    {
+        //        buffer = ReplaceIgnoreCase(buffer, escapableWhiteChars[i].ToLower(locale),
+        //            "\\", locale);
+        //    }
+        //    return buffer;
+        //}
 
         /**
          * escape all tokens that are part of the parser syntax on a given string

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
index d384076..147c411 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
@@ -110,31 +110,31 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             }
         }
 
-        public int GetColumn()
+        public int Column
         {
-            return bufferStart + bufferPosition;
+            get { return bufferStart + bufferPosition; }
         }
-        public int GetLine()
+        public int Line
         {
-            return 1;
+            get { return 1; }
         }
-        public int GetEndColumn()
+        public int EndColumn
         {
-            return bufferStart + bufferPosition;
+            get { return bufferStart + bufferPosition; }
         }
-        public int GetEndLine()
+        public int EndLine
         {
-            return 1;
+            get { return 1; }
         }
 
-        public int GetBeginColumn()
+        public int BeginColumn
         {
-            return bufferStart + tokenStart;
+            get { return bufferStart + tokenStart; }
         }
 
-        public int GetBeginLine()
+        public int BeginLine
         {
-            return 1;
+            get { return 1; }
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
index a6d8952..04f77ff 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
@@ -822,10 +822,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             int endColumn;
             string im = jjstrLiteralImages[jjmatchedKind];
             curTokenImage = (im == null) ? input_stream.GetImage() : im;
-            beginLine = input_stream.GetBeginLine();
-            beginColumn = input_stream.GetBeginColumn();
-            endLine = input_stream.GetEndLine();
-            endColumn = input_stream.GetEndColumn();
+            beginLine = input_stream.BeginLine;
+            beginColumn = input_stream.BeginColumn;
+            endLine = input_stream.EndLine;
+            endColumn = input_stream.EndColumn;
             t = Token.NewToken(jjmatchedKind, curTokenImage);
 
             t.beginLine = beginLine;
@@ -899,8 +899,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                         goto EOFLoop_continue;
                     }
                 }
-                int error_line = input_stream.GetEndLine();
-                int error_column = input_stream.GetEndColumn();
+                int error_line = input_stream.EndLine;
+                int error_column = input_stream.EndColumn;
                 string error_after = null;
                 bool EOFSeen = false;
                 try { input_stream.ReadChar(); input_stream.BackUp(1); }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
index 03a4bea..58d2e30 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
@@ -72,9 +72,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
          * Any subclass of Token that actually wants to return a non-null value can
          * override this method as appropriate.
          */
-        public object GetValue()
+        public virtual object Value
         {
-            return null;
+            get { return null; }
         }
 
         /**

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
index 4510388..2e050ed 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                 && !(node is WildcardQueryNode)
                 && !(node is FuzzyQueryNode)
                 && !(node is RegexpQueryNode)
-                && !(node.GetParent() is IRangeQueryNode))
+                && !(node.Parent is IRangeQueryNode))
             {
 
                 FieldQueryNode fieldNode = ((FieldQueryNode)node);
@@ -314,11 +314,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                                     if (this.positionIncrementsEnabled)
                                     {
-                                        termNode.SetPositionIncrement(position);
+                                        termNode.PositionIncrement = position;
                                     }
                                     else
                                     {
-                                        termNode.SetPositionIncrement(termGroupCount);
+                                        termNode.PositionIncrement = termGroupCount;
                                     }
 
                                     mpq.Add(termNode);
@@ -343,12 +343,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                             if (this.positionIncrementsEnabled)
                             {
-                                termNode.SetPositionIncrement(position);
+                                termNode.PositionIncrement = position;
 
                             }
                             else
                             {
-                                termNode.SetPositionIncrement(termGroupCount);
+                                termNode.PositionIncrement = termGroupCount;
                             }
 
                             mpq.Add(termNode);
@@ -394,12 +394,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         if (this.positionIncrementsEnabled)
                         {
                             position += positionIncrement;
-                            newFieldNode.SetPositionIncrement(position);
+                            newFieldNode.PositionIncrement = position;
 
                         }
                         else
                         {
-                            newFieldNode.SetPositionIncrement(i);
+                            newFieldNode.PositionIncrement = i;
                         }
 
                         pq.Add(newFieldNode);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
index 6e986d7..6c5ed50 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
@@ -127,7 +127,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
         protected virtual IQueryNode PreProcessNode(IQueryNode node)
         {
-            IQueryNode parent = node.GetParent();
+            IQueryNode parent = node.Parent;
             if (node is BooleanQueryNode)
             {
                 if (parent is BooleanQueryNode)
@@ -168,7 +168,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
             {
                 ModifierQueryNode modNode = (ModifierQueryNode)node;
 
-                if (modNode.GetModifier() == Modifier.MOD_NONE)
+                if (modNode.Modifier == Modifier.MOD_NONE)
                 {
                     return new ModifierQueryNode(modNode.GetChild(), mod);
                 }
@@ -184,7 +184,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
             if (node is ModifierQueryNode)
             {
                 ModifierQueryNode modNode = (ModifierQueryNode)node;
-                if (modNode.GetModifier() == Modifier.MOD_NONE)
+                if (modNode.Modifier == Modifier.MOD_NONE)
                 {
                     node.SetTag(TAG_MODIFIER, mod);
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
index 36637e6..a6dbc75 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
@@ -40,7 +40,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         ModifierQueryNode modNode = (ModifierQueryNode)child;
 
                         if (modNode is BooleanModifierNode
-                            || modNode.GetModifier() == Modifier.MOD_NONE)
+                            || modNode.Modifier == Modifier.MOD_NONE)
                         {
 
                             return child;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
index 03776d2..3d9b5f2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
         {
 
             if (node is IFieldableNode &&
-                (node.GetParent() == null || !(node.GetParent() is IFieldableNode)))
+                (node.Parent == null || !(node.Parent is IFieldableNode)))
             {
 
                 IFieldableNode fieldNode = (IFieldableNode)node;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
index 59fc57d..13b309b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
@@ -44,15 +44,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                 if (config != null && (fuzzyConfig = config.Get(ConfigurationKeys.FUZZY_CONFIG)) != null)
                 {
-                    fuzzyNode.SetPrefixLength(fuzzyConfig.GetPrefixLength());
+                    fuzzyNode.PrefixLength = fuzzyConfig.PrefixLength;
 
-                    if (fuzzyNode.GetSimilarity() < 0)
+                    if (fuzzyNode.Similarity < 0)
                     {
-                        fuzzyNode.SetSimilarity(fuzzyConfig.GetMinSimilarity());
+                        fuzzyNode.Similarity = fuzzyConfig.MinSimilarity;
                     }
 
                 }
-                else if (fuzzyNode.GetSimilarity() < 0)
+                else if (fuzzyNode.Similarity < 0)
                 {
                     throw new ArgumentException("No FUZZY_CONFIG set in the config");
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
index d13f79e..d99c5b7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                         ModifierQueryNode modNode = (ModifierQueryNode)node;
 
-                        if (modNode.GetModifier() == Modifier.MOD_REQ)
+                        if (modNode.Modifier == Modifier.MOD_REQ)
                         {
                             return modNode.GetChild();
                         }
@@ -123,7 +123,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                         ModifierQueryNode modNode = (ModifierQueryNode)node;
 
-                        if (modNode.GetModifier() == Modifier.MOD_NONE)
+                        if (modNode.Modifier == Modifier.MOD_NONE)
                         {
                             return new BooleanModifierNode(modNode.GetChild(), Modifier.MOD_REQ);
                         }
@@ -140,7 +140,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
             else
             {
 
-                if (node.GetParent() is AndQueryNode)
+                if (node.Parent is AndQueryNode)
                 {
 
                     if (node is ModifierQueryNode)
@@ -148,7 +148,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                         ModifierQueryNode modNode = (ModifierQueryNode)node;
 
-                        if (modNode.GetModifier() == Modifier.MOD_NONE)
+                        if (modNode.Modifier == Modifier.MOD_NONE)
                         {
                             return new BooleanModifierNode(modNode.GetChild(), Modifier.MOD_REQ);
                         }
@@ -218,7 +218,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
             }
             else if (!(node is BooleanQueryNode))
             {
-                this.queryNodeList.Add(ApplyModifier(node, node.GetParent()));
+                this.queryNodeList.Add(ApplyModifier(node, node.Parent));
                 this.latestNodeVerified = false;
 
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
index ce22ea0..505ed07 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
@@ -54,7 +54,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
             if (node is WildcardQueryNode
                 || node is FuzzyQueryNode
-                || (node is FieldQueryNode && node.GetParent() is IRangeQueryNode)
+                || (node is FieldQueryNode && node.Parent is IRangeQueryNode)
                 || node is RegexpQueryNode)
             {
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
index de5a5b4..2bbffe4 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
@@ -50,7 +50,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
         {
 
             if (node is FieldQueryNode
-                && !(node.GetParent() is IRangeQueryNode))
+                && !(node.Parent is IRangeQueryNode))
             {
 
                 QueryConfigHandler config = GetQueryConfigHandler();
@@ -70,7 +70,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         {
 
                             /*NumberFormat*/
-                            string numberFormat = numericConfig.GetNumberFormat();
+                            string numberFormat = numericConfig.NumberFormat;
                             string text = fieldNode.GetTextAsString();
                             /*Number*/
                             object number = null;
@@ -92,7 +92,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                             .AssemblyQualifiedName), e);
                                 }
 
-                                switch (numericConfig.GetType())
+                                switch (numericConfig.Type)
                                 {
                                     case FieldType.NumericType.LONG:
                                         number = Convert.ToInt64(number);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
index f78e218..88ed011 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                             string lowerText = lower.GetTextAsString();
                             string upperText = upper.GetTextAsString();
-                            /*NumberFormat*/ string numberFormat = numericConfig.GetNumberFormat();
+                            /*NumberFormat*/ string numberFormat = numericConfig.NumberFormat;
                             /*Number*/
                             object lowerNumber = null, upperNumber = null;
 
@@ -108,7 +108,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                             }
 
-                            switch (numericConfig.GetType())
+                            switch (numericConfig.Type)
                             {
                                 case FieldType.NumericType.LONG:
                                     if (upperNumber != null) upperNumber = Convert.ToInt64(upperNumber);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
index 896f749..c4bdd53 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
@@ -34,7 +34,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
         {
             queryTree = base.Process(queryTree);
 
-            if (!queryTree.IsLeaf())
+            if (!queryTree.IsLeaf)
             {
 
                 IList<IQueryNode> children = queryTree.GetChildren();
@@ -76,7 +76,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                 foreach (IQueryNode child in children)
                 {
 
-                    if (!child.IsLeaf())
+                    if (!child.IsLeaf)
                     {
 
                         IList<IQueryNode> grandChildren = child.GetChildren();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
index b38f60b..868daed 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
@@ -40,7 +40,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                 // do not process wildcards for TermRangeQueryNode children and 
                 // QuotedFieldQueryNode to reproduce the old parser behavior
-                if (fqn.GetParent() is TermRangeQueryNode
+                if (fqn.Parent is TermRangeQueryNode
                     || fqn is QuotedFieldQueryNode
                     || text.Length <= 0)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
index 7d7d94e..9819378 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
@@ -51,7 +51,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override string ToString()
         {
-            return "<StandardQueryParser config=\"" + this.GetQueryConfigHandler()
+            return "<StandardQueryParser config=\"" + this.QueryConfigHandler
                 + "\"/>";
         }
 
@@ -81,35 +81,36 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
          * Gets implicit operator setting, which will be either {@link Operator#AND}
          * or {@link Operator#OR}.
          */
-        public virtual Operator? GetDefaultOperator()
+        public virtual Operator? DefaultOperator
         {
-            return GetQueryConfigHandler().Get(ConfigurationKeys.DEFAULT_OPERATOR);
+            get { return QueryConfigHandler.Get(ConfigurationKeys.DEFAULT_OPERATOR); }
+            set { QueryConfigHandler.Set(ConfigurationKeys.DEFAULT_OPERATOR, value); }
         }
 
-        /**
-         * Sets the boolean operator of the QueryParser. In default mode (
-         * {@link Operator#OR}) terms without any modifiers are considered optional:
-         * for example <code>capital of Hungary</code> is equal to
-         * <code>capital OR of OR Hungary</code>.<br/>
-         * In {@link Operator#AND} mode terms are considered to be in conjunction: the
-         * above mentioned query is parsed as <code>capital AND of AND Hungary</code>
-         */
-        public virtual void SetDefaultOperator(Operator @operator)
-        {
-            GetQueryConfigHandler().Set(ConfigurationKeys.DEFAULT_OPERATOR, @operator);
-        }
+        ///**
+        // * Sets the boolean operator of the QueryParser. In default mode (
+        // * {@link Operator#OR}) terms without any modifiers are considered optional:
+        // * for example <code>capital of Hungary</code> is equal to
+        // * <code>capital OR of OR Hungary</code>.<br/>
+        // * In {@link Operator#AND} mode terms are considered to be in conjunction: the
+        // * above mentioned query is parsed as <code>capital AND of AND Hungary</code>
+        // */
+        //public virtual void SetDefaultOperator(Operator @operator)
+        //{
+        //    QueryConfigHandler.Set(ConfigurationKeys.DEFAULT_OPERATOR, @operator);
+        //}
 
 
         public virtual bool LowercaseExpandedTerms
         {
             get
             {
-                bool? lowercaseExpandedTerms = GetQueryConfigHandler().Get(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS);
+                bool? lowercaseExpandedTerms = QueryConfigHandler.Get(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS);
                 return lowercaseExpandedTerms.HasValue ? lowercaseExpandedTerms.Value : true;
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS, value);
+                QueryConfigHandler.Set(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS, value);
             }
         }
 
@@ -152,12 +153,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                bool? allowLeadingWildcard = GetQueryConfigHandler().Get(ConfigurationKeys.ALLOW_LEADING_WILDCARD);
+                bool? allowLeadingWildcard = QueryConfigHandler.Get(ConfigurationKeys.ALLOW_LEADING_WILDCARD);
                 return allowLeadingWildcard.HasValue ? allowLeadingWildcard.Value : false;
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.ALLOW_LEADING_WILDCARD, value);
+                QueryConfigHandler.Set(ConfigurationKeys.ALLOW_LEADING_WILDCARD, value);
             }
         }
 
@@ -180,12 +181,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                bool? enablePositionsIncrements = GetQueryConfigHandler().Get(ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
+                bool? enablePositionsIncrements = QueryConfigHandler.Get(ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
                 return enablePositionsIncrements.HasValue ? enablePositionsIncrements.Value : false;
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.ENABLE_POSITION_INCREMENTS, value);
+                QueryConfigHandler.Set(ConfigurationKeys.ENABLE_POSITION_INCREMENTS, value);
             }
         }
 
@@ -228,11 +229,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                return GetQueryConfigHandler().Get(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD);
+                return QueryConfigHandler.Get(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD);
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD, value);
+                QueryConfigHandler.Set(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD, value);
             }
         }
 
@@ -275,7 +276,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
                 fields = new string[0];
             }
 
-            GetQueryConfigHandler().Set(ConfigurationKeys.MULTI_FIELDS, fields);
+            QueryConfigHandler.Set(ConfigurationKeys.MULTI_FIELDS, fields);
 
         }
 
@@ -285,16 +286,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
          * 
          * @param fields the fields used to expand the query
          */
-        public virtual void GetMultiFields(string[] fields)
+        public virtual string[] GetMultiFields()
         {
-            GetQueryConfigHandler().Get(ConfigurationKeys.MULTI_FIELDS);
+            return QueryConfigHandler.Get(ConfigurationKeys.MULTI_FIELDS);
         }
 
         public virtual int FuzzyPrefixLength
         {
             get
             {
-                FuzzyConfig fuzzyConfig = GetQueryConfigHandler().Get(ConfigurationKeys.FUZZY_CONFIG);
+                FuzzyConfig fuzzyConfig = QueryConfigHandler.Get(ConfigurationKeys.FUZZY_CONFIG);
 
                 if (fuzzyConfig == null)
                 {
@@ -302,12 +303,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
                 }
                 else
                 {
-                    return fuzzyConfig.GetPrefixLength();
+                    return fuzzyConfig.PrefixLength;
                 }
             }
             set
             {
-                QueryConfigHandler config = GetQueryConfigHandler();
+                QueryConfigHandler config = QueryConfigHandler;
                 FuzzyConfig fuzzyConfig = config.Get(ConfigurationKeys.FUZZY_CONFIG);
 
                 if (fuzzyConfig == null)
@@ -316,7 +317,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
                     config.Set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig);
                 }
 
-                fuzzyConfig.SetPrefixLength(value);
+                fuzzyConfig.PrefixLength = value;
             }
         }
 
@@ -342,25 +343,26 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         //}
 
-        public virtual void SetNumericConfigMap(IDictionary<string, NumericConfig> numericConfigMap)
-        {
-            GetQueryConfigHandler().Set(ConfigurationKeys.NUMERIC_CONFIG_MAP, numericConfigMap);
-        }
+        //public virtual void SetNumericConfigMap(IDictionary<string, NumericConfig> numericConfigMap)
+        //{
+        //    QueryConfigHandler.Set(ConfigurationKeys.NUMERIC_CONFIG_MAP, numericConfigMap);
+        //}
 
-        public virtual IDictionary<string, NumericConfig> GetNumericConfigMap()
+        public virtual IDictionary<string, NumericConfig> NumericConfigMap
         {
-            return GetQueryConfigHandler().Get(ConfigurationKeys.NUMERIC_CONFIG_MAP);
+            get { return QueryConfigHandler.Get(ConfigurationKeys.NUMERIC_CONFIG_MAP); }
+            set { QueryConfigHandler.Set(ConfigurationKeys.NUMERIC_CONFIG_MAP, value); }
         }
 
         public virtual CultureInfo Locale
         {
             get
             {
-                return GetQueryConfigHandler().Get(ConfigurationKeys.LOCALE);
+                return QueryConfigHandler.Get(ConfigurationKeys.LOCALE);
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.LOCALE, value);
+                QueryConfigHandler.Set(ConfigurationKeys.LOCALE, value);
             }
         }
 
@@ -386,11 +388,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                return GetQueryConfigHandler().Get(ConfigurationKeys.TIMEZONE);
+                return QueryConfigHandler.Get(ConfigurationKeys.TIMEZONE);
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.TIMEZONE, value);
+                QueryConfigHandler.Set(ConfigurationKeys.TIMEZONE, value);
             }
         }
 
@@ -414,7 +416,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         [Obsolete]
         public virtual void SetDefaultPhraseSlop(int defaultPhraseSlop)
         {
-            GetQueryConfigHandler().Set(ConfigurationKeys.PHRASE_SLOP, defaultPhraseSlop);
+            QueryConfigHandler.Set(ConfigurationKeys.PHRASE_SLOP, defaultPhraseSlop);
         }
 
         ///**
@@ -431,11 +433,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                return GetQueryConfigHandler().Get(ConfigurationKeys.ANALYZER);
+                return QueryConfigHandler.Get(ConfigurationKeys.ANALYZER);
             }
             set
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.ANALYZER, value);
+                QueryConfigHandler.Set(ConfigurationKeys.ANALYZER, value);
             }
         }
 
@@ -502,12 +504,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                int? phraseSlop = GetQueryConfigHandler().Get(ConfigurationKeys.PHRASE_SLOP);
+                int? phraseSlop = QueryConfigHandler.Get(ConfigurationKeys.PHRASE_SLOP);
                 return phraseSlop.HasValue ? phraseSlop.Value : 0;
             }
             set // LUCENENET TODO: obsolete
             {
-                GetQueryConfigHandler().Set(ConfigurationKeys.PHRASE_SLOP, value);
+                QueryConfigHandler.Set(ConfigurationKeys.PHRASE_SLOP, value);
             }
         }
 
@@ -534,12 +536,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             get
             {
-                FuzzyConfig fuzzyConfig = GetQueryConfigHandler().Get(ConfigurationKeys.FUZZY_CONFIG);
-                return (fuzzyConfig != null) ? fuzzyConfig.GetMinSimilarity() : FuzzyQuery.DefaultMinSimilarity;
+                FuzzyConfig fuzzyConfig = QueryConfigHandler.Get(ConfigurationKeys.FUZZY_CONFIG);
+                return (fuzzyConfig != null) ? fuzzyConfig.MinSimilarity : FuzzyQuery.DefaultMinSimilarity;
             }
             set
             {
-                QueryConfigHandler config = GetQueryConfigHandler();
+                QueryConfigHandler config = QueryConfigHandler;
                 FuzzyConfig fuzzyConfig = config.Get(ConfigurationKeys.FUZZY_CONFIG);
 
                 if (fuzzyConfig == null)
@@ -548,7 +550,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
                     config.Set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig);
                 }
 
-                fuzzyConfig.SetMinSimilarity(value);
+                fuzzyConfig.MinSimilarity = value;
             }
         }
 
@@ -571,36 +573,37 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         //    fuzzyConfig.SetMinSimilarity(fuzzyMinSim);
         //}
 
-        /**
-         * Sets the boost used for each field.
-         * 
-         * @param boosts a collection that maps a field to its boost 
-         */
-        public virtual void SetFieldsBoost(IDictionary<string, float?> boosts)
-        {
-            GetQueryConfigHandler().Set(ConfigurationKeys.FIELD_BOOST_MAP, boosts);
-        }
+        ///**
+        // * Sets the boost used for each field.
+        // * 
+        // * @param boosts a collection that maps a field to its boost 
+        // */
+        //public virtual void SetFieldsBoost(IDictionary<string, float?> boosts)
+        //{
+        //    QueryConfigHandler.Set(ConfigurationKeys.FIELD_BOOST_MAP, boosts);
+        //}
 
         /**
          * Returns the field to boost map used to set boost for each field.
          * 
          * @return the field to boost map 
          */
-        public virtual IDictionary<string, float?> GetFieldsBoost()
+        public virtual IDictionary<string, float?> FieldsBoost
         {
-            return GetQueryConfigHandler().Get(ConfigurationKeys.FIELD_BOOST_MAP);
+            get { return QueryConfigHandler.Get(ConfigurationKeys.FIELD_BOOST_MAP); }
+            set { QueryConfigHandler.Set(ConfigurationKeys.FIELD_BOOST_MAP, value); }
         }
 
-        /**
-         * Sets the default {@link Resolution} used for certain field when
-         * no {@link Resolution} is defined for this field.
-         * 
-         * @param dateResolution the default {@link Resolution}
-         */
+        ///**
+        // * Sets the default {@link Resolution} used for certain field when
+        // * no {@link Resolution} is defined for this field.
+        // * 
+        // * @param dateResolution the default {@link Resolution}
+        // */
 
         public virtual void SetDateResolution(DateTools.Resolution dateResolution)
         {
-            GetQueryConfigHandler().Set(ConfigurationKeys.DATE_RESOLUTION, dateResolution);
+            QueryConfigHandler.Set(ConfigurationKeys.DATE_RESOLUTION, dateResolution);
         }
 
         /**
@@ -609,9 +612,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
          * 
          * @return the default {@link Resolution}
          */
-        public virtual DateTools.Resolution? GetDateResolution()
+        public virtual DateTools.Resolution DateResolution
         {
-            return GetQueryConfigHandler().Get(ConfigurationKeys.DATE_RESOLUTION);
+            get { return QueryConfigHandler.Get(ConfigurationKeys.DATE_RESOLUTION); }
         }
 
         /**
@@ -624,7 +627,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         [Obsolete]
         public virtual void SetDateResolution(IDictionary<string, DateTools.Resolution?> dateRes)
         {
-            SetDateResolutionMap(dateRes);
+            DateResolutionMap = dateRes;
         }
 
         /**
@@ -632,19 +635,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
          * 
          * @return the field to {@link Resolution} map
          */
-        public virtual IDictionary<string, DateTools.Resolution?> GetDateResolutionMap()
+        public virtual IDictionary<string, DateTools.Resolution?> DateResolutionMap
         {
-            return GetQueryConfigHandler().Get(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP);
+            get { return QueryConfigHandler.Get(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP); }
+            set { QueryConfigHandler.Set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP, value); }
         }
 
-        /**
-         * Sets the {@link Resolution} used for each field
-         * 
-         * @param dateRes a collection that maps a field to its {@link Resolution}
-         */
-        public virtual void SetDateResolutionMap(IDictionary<string, DateTools.Resolution?> dateRes)
-        {
-            GetQueryConfigHandler().Set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP, dateRes);
-        }
+        ///**
+        // * Sets the {@link Resolution} used for each field
+        // * 
+        // * @param dateRes a collection that maps a field to its {@link Resolution}
+        // */
+        //public virtual void SetDateResolutionMap(IDictionary<string, DateTools.Resolution?> dateRes)
+        //{
+        //    QueryConfigHandler.Set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP, dateRes);
+        //}
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Core/Nodes/TestQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Core/Nodes/TestQueryNode.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Core/Nodes/TestQueryNode.cs
index a09f296..bc276ed 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Core/Nodes/TestQueryNode.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Core/Nodes/TestQueryNode.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             IQueryNode node = new FieldQueryNode("foo", "A", 0, 1);
 
             node.SetTag("TaG", new Object());
-            assertTrue(node.GetTagMap().size() > 0);
+            assertTrue(node.TagMap.size() > 0);
             assertTrue(node.ContainsTag("tAg"));
             assertTrue(node.GetTag("tAg") != null);
 
@@ -42,19 +42,19 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         {
             BooleanQueryNode booleanNode = new BooleanQueryNode(Collections.EmptyList<IQueryNode>());
             FieldQueryNode fieldNode = new FieldQueryNode("foo", "A", 0, 1);
-            assertNull(fieldNode.GetParent());
+            assertNull(fieldNode.Parent);
 
             booleanNode.Add(fieldNode);
-            assertNotNull(fieldNode.GetParent());
+            assertNotNull(fieldNode.Parent);
 
             fieldNode.RemoveFromParent();
-            assertNull(fieldNode.GetParent());
+            assertNull(fieldNode.Parent);
 
             booleanNode.Add(fieldNode);
-            assertNotNull(fieldNode.GetParent());
+            assertNotNull(fieldNode.Parent);
 
             booleanNode.Set(Collections.EmptyList<IQueryNode>());
-            assertNull(fieldNode.GetParent());
+            assertNull(fieldNode.Parent);
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Precedence/TestPrecedenceQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Precedence/TestPrecedenceQueryParser.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Precedence/TestPrecedenceQueryParser.cs
index 029f2bb..4c48617 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Precedence/TestPrecedenceQueryParser.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Precedence/TestPrecedenceQueryParser.cs
@@ -129,7 +129,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence
                 a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true);
             PrecedenceQueryParser qp = new PrecedenceQueryParser();
             qp.Analyzer = (a);
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.OR); // LUCENENET TODO: Change API back to the way it was..?
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.OR); // LUCENENET TODO: Change API back to the way it was..?
             return qp;
         }
 
@@ -181,7 +181,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence
                 a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true);
             PrecedenceQueryParser qp = new PrecedenceQueryParser();
             qp.Analyzer = (a);
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             return qp.Parse(query, "field");
         }
 
@@ -244,11 +244,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence
             PrecedenceQueryParser qp = new PrecedenceQueryParser();
             qp.Analyzer = (new MockAnalyzer(Random()));
             // make sure OR is the default:
-            assertEquals(/*StandardQueryConfigHandler.*/Operator.OR, qp.GetDefaultOperator());
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/ Operator.AND);
-            assertEquals(/*StandardQueryConfigHandler.*/ Operator.AND, qp.GetDefaultOperator());
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/ Operator.OR);
-            assertEquals(/*StandardQueryConfigHandler.*/ Operator.OR, qp.GetDefaultOperator());
+            assertEquals(/*StandardQueryConfigHandler.*/Operator.OR, qp.DefaultOperator);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/ Operator.AND);
+            assertEquals(/*StandardQueryConfigHandler.*/ Operator.AND, qp.DefaultOperator);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/ Operator.OR);
+            assertEquals(/*StandardQueryConfigHandler.*/ Operator.OR, qp.DefaultOperator);
 
             assertQueryEquals("a OR !b", null, "a -b");
             assertQueryEquals("a OR ! b", null, "a -b");
@@ -694,7 +694,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence
             query2 = parser.Parse("A (-B +C)", "field");
             assertEquals(query1, query2);
 
-            parser.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            parser.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             query1 = parser.Parse("A AND B OR C AND D", "field");
             query2 = parser.Parse("(A AND B) OR (C AND D)", "field");
             assertEquals(query1, query2);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiAnalyzerQPHelper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiAnalyzerQPHelper.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiAnalyzerQPHelper.cs
index d67bcb7..850e52b 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiAnalyzerQPHelper.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiAnalyzerQPHelper.cs
@@ -85,7 +85,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             qp.SetDefaultPhraseSlop(0);
 
             // non-default operator:
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             assertEquals("+(multi multi2) +foo", qp.Parse("multi foo", "").toString());
 
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiFieldQPHelper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiFieldQPHelper.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiFieldQPHelper.cs
index 9ed9397..e62d5bc 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiFieldQPHelper.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestMultiFieldQPHelper.cs
@@ -118,7 +118,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             assertEquals("(b:one t:one) f:two", q.toString());
 
             // AND mode:
-            mfqp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            mfqp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             q = mfqp.Parse("one two", null);
             assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
             q = mfqp.Parse("\"aa bb cc\" \"dd ee\"", null);
@@ -136,7 +136,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             String[] fields = { "b", "t" };
             StandardQueryParser mfqp = new StandardQueryParser();
             mfqp.SetMultiFields(fields);
-            mfqp.SetFieldsBoost(boosts);
+            mfqp.FieldsBoost = (boosts);
             mfqp.Analyzer = (new MockAnalyzer(Random()));
 
             // Check for simple
@@ -361,7 +361,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
             mfqp.SetMultiFields(new String[] { "body" });
             mfqp.Analyzer = (analyzer);
-            mfqp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            mfqp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             Query q = mfqp.Parse("the footest", null);
             IndexReader ir = DirectoryReader.Open(ramDir);
             IndexSearcher @is = NewSearcher(ir);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestQPHelper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestQPHelper.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestQPHelper.cs
index c59896f..849f826 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestQPHelper.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestQPHelper.cs
@@ -122,7 +122,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             public QPTestParser(Analyzer a)
             {
-                ((QueryNodeProcessorPipeline)GetQueryNodeProcessor())
+                ((QueryNodeProcessorPipeline)QueryNodeProcessor)
                     .Add(new QPTestParserQueryNodeProcessor());
                 this.Analyzer = (a);
 
@@ -184,7 +184,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             StandardQueryParser qp = new StandardQueryParser();
             qp.Analyzer = (a);
 
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.OR);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.OR);
 
             return qp;
 
@@ -286,7 +286,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
                 a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true);
             StandardQueryParser qp = new StandardQueryParser();
             qp.Analyzer = (a);
-            qp.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            qp.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
 
             return qp.Parse(query, "field");
 
@@ -1424,7 +1424,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
             StandardQueryParser parser = new StandardQueryParser();
             parser.SetMultiFields(fields);
-            parser.SetDefaultOperator(/*StandardQueryConfigHandler.*/Operator.AND);
+            parser.DefaultOperator = (/*StandardQueryConfigHandler.*/Operator.AND);
             parser.Analyzer = (new MockAnalyzer(Random()));
 
             BooleanQuery exp = new BooleanQuery();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/0aa30ca8/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
index 5ceeff1..fd61069 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             if (a == null) a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true);
             StandardQueryParser qp = new StandardQueryParser(a);
-            qp.SetDefaultOperator(Config.Operator.OR);
+            qp.DefaultOperator = (Config.Operator.OR);
 
             return qp;
         }
@@ -70,7 +70,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             Debug.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
-            qp.SetDefaultOperator(Config.Operator.OR);
+            qp.DefaultOperator = (Config.Operator.OR);
         }
 
 
@@ -78,7 +78,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             Debug.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
-            qp.SetDefaultOperator(Config.Operator.AND);
+            qp.DefaultOperator = (Config.Operator.AND);
         }
 
 
@@ -101,7 +101,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             Debug.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
-            qp.GetDateResolutionMap().Put(field, value);
+            qp.DateResolutionMap.Put(field, value);
         }
 
 
@@ -203,11 +203,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         {
             StandardQueryParser qp = GetParser(new MockAnalyzer(Random()));
             // make sure OR is the default:
-            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.OR, qp.GetDefaultOperator());
+            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.OR, qp.DefaultOperator);
             SetDefaultOperatorAND(qp);
-            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.AND, qp.GetDefaultOperator());
+            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.AND, qp.DefaultOperator);
             SetDefaultOperatorOR(qp);
-            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.OR, qp.GetDefaultOperator());
+            assertEquals(/*StandardQueryConfigHandler.*/Config.Operator.OR, qp.DefaultOperator);
         }
 
 


Mime
View raw message