lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [42/58] lucenenet git commit: QueryParser.Flexible: Documentation comments
Date Tue, 06 Dec 2016 15:12:17 GMT
QueryParser.Flexible: Documentation comments


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/c6696fe8
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/c6696fe8
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/c6696fe8

Branch: refs/heads/master
Commit: c6696fe8a36aed83a9476013736ad13dca89c0ba
Parents: 0700747
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Mon Dec 5 19:18:10 2016 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Mon Dec 5 20:25:29 2016 +0700

----------------------------------------------------------------------
 .../Flexible/Core/Builders/QueryTreeBuilder.cs  |  60 ++---
 .../Flexible/Core/Config/AbstractQueryConfig.cs |  60 +++--
 .../Flexible/Core/Config/ConfigurationKey.cs    |   4 +-
 .../Flexible/Core/Config/FieldConfig.cs         |  19 +-
 .../Flexible/Core/Config/FieldConfigListener.cs |   4 +-
 .../Flexible/Core/Config/QueryConfigHandler.cs  |  46 ++--
 .../Flexible/Core/Nodes/AndQueryNode.cs         |  10 +-
 .../Flexible/Core/Nodes/AnyQueryNode.cs         |  22 +-
 .../Flexible/Core/Nodes/BooleanQueryNode.cs     |  10 +-
 .../Flexible/Core/Nodes/BoostQueryNode.cs       |  40 ++--
 .../Flexible/Core/Nodes/DeletedQueryNode.cs     |   4 +-
 .../Flexible/Core/Nodes/FieldQueryNode.cs       |  82 ++++---
 .../Core/Nodes/FieldValuePairQueryNode.cs       |   2 +-
 .../Flexible/Core/Nodes/FieldableNode.cs        |   2 +-
 .../Flexible/Core/Nodes/FuzzyQueryNode.cs       |  54 ++---
 .../Flexible/Core/Nodes/GroupQueryNode.cs       |   8 +-
 .../Core/Nodes/MatchAllDocsQueryNode.cs         |   2 +-
 .../Flexible/Core/Nodes/MatchNoDocsQueryNode.cs |   2 +-
 .../Flexible/Core/Nodes/ModifierQueryNode.cs    |  24 +-
 .../Core/Nodes/NoTokenFoundQueryNode.cs         |   2 +-
 .../Flexible/Core/Nodes/OpaqueQueryNode.cs      |  25 +--
 .../Flexible/Core/Nodes/OrQueryNode.cs          |  10 +-
 .../Flexible/Core/Nodes/PathQueryNode.cs        |  99 ++++-----
 .../Flexible/Core/Nodes/PhraseSlopQueryNode.cs  |  11 +-
 .../Flexible/Core/Nodes/ProximityQueryNode.cs   |  80 +++----
 .../Flexible/Core/Nodes/QueryNode.cs            |  77 ++++---
 .../Flexible/Core/Nodes/QueryNodeImpl.cs        |  58 ++---
 .../Flexible/Core/Nodes/QuotedFieldQueryNode.cs |  36 ++-
 .../Flexible/Core/Nodes/RangeQueryNode.cs       |   2 +-
 .../Flexible/Core/Nodes/SlopQueryNode.cs        |  13 +-
 .../Flexible/Core/Nodes/TextableQueryNode.cs    |   2 +-
 .../Core/Nodes/TokenizedPhraseQueryNode.cs      |   2 +-
 .../Flexible/Core/Nodes/ValueQueryNode.cs       |   4 +-
 .../Flexible/Core/Parser/EscapeQuerySyntax.cs   |   8 +-
 .../Flexible/Core/Parser/SyntaxParser.cs        |   2 +-
 .../NoChildOptimizationQueryNodeProcessor.cs    |   2 +-
 .../Core/Processors/QueryNodeProcessor.cs       |  49 ++--
 .../Core/Processors/QueryNodeProcessorImpl.cs   | 143 ++++++------
 .../Processors/QueryNodeProcessorPipeline.cs    | 141 +++++++-----
 .../RemoveDeletedQueryNodesProcessor.cs         |   6 +-
 .../Flexible/Core/QueryNodeError.cs             |  39 ++--
 .../Flexible/Core/QueryNodeException.cs         |   8 +-
 .../Flexible/Core/QueryNodeParseException.cs    |  30 ++-
 .../Flexible/Core/QueryParserHelper.cs          | 222 ++++++++-----------
 .../Flexible/Core/Util/QueryNodeOperation.cs    |  18 +-
 .../Flexible/Core/Util/UnescapedCharSequence.cs |  47 ++--
 .../Flexible/Messages/MessageImpl.cs            |   5 -
 .../Flexible/Messages/NLS.cs                    |  24 +-
 .../Precedence/PrecedenceQueryParser.cs         |  18 +-
 .../BooleanModifiersQueryNodeProcessor.cs       |  15 +-
 .../PrecedenceQueryNodeProcessorPipeline.cs     |  12 +-
 .../Standard/Builders/AnyQueryNodeBuilder.cs    |  10 +-
 .../Builders/BooleanQueryNodeBuilder.cs         |  10 +-
 .../Standard/Builders/BoostQueryNodeBuilder.cs  |   8 +-
 .../Standard/Builders/DummyQueryNodeBuilder.cs  |   6 +-
 .../Standard/Builders/FieldQueryNodeBuilder.cs  |   2 +-
 .../Standard/Builders/FuzzyQueryNodeBuilder.cs  |   2 +-
 .../Standard/Builders/GroupQueryNodeBuilder.cs  |   6 +-
 .../Builders/MatchAllDocsQueryNodeBuilder.cs    |   4 +-
 .../Builders/MatchNoDocsQueryNodeBuilder.cs     |   4 +-
 .../Builders/ModifierQueryNodeBuilder.cs        |   6 +-
 .../Builders/MultiPhraseQueryNodeBuilder.cs     |   2 +-
 .../Builders/NumericRangeQueryNodeBuilder.cs    |   8 +-
 .../Standard/Builders/PhraseQueryNodeBuilder.cs |   2 +-
 .../Builders/PrefixWildcardQueryNodeBuilder.cs  |   2 +-
 .../Standard/Builders/RegexpQueryNodeBuilder.cs |   2 +-
 .../Standard/Builders/SlopQueryNodeBuilder.cs   |   8 +-
 .../Builders/StandardBooleanQueryNodeBuilder.cs |   6 +-
 .../Standard/Builders/StandardQueryBuilder.cs   |   4 +-
 .../Builders/StandardQueryTreeBuilder.cs        |   6 +-
 .../Builders/TermRangeQueryNodeBuilder.cs       |   2 +-
 .../Builders/WildcardQueryNodeBuilder.cs        |   2 +-
 .../Standard/CommonQueryParserConfiguration.cs  |  30 +--
 .../Standard/Config/FieldBoostMapFCListener.cs  |  10 +-
 .../Config/FieldDateResolutionFCListener.cs     |   6 +-
 .../Flexible/Standard/Config/FuzzyConfig.cs     |   2 +-
 .../Standard/Config/NumberDateFormat.cs         |  24 +-
 .../Flexible/Standard/Config/NumericConfig.cs   |  60 ++---
 .../Config/NumericFieldConfigListener.cs        |  21 +-
 .../Config/StandardQueryConfigHandler.cs        | 185 +++++++---------
 .../Standard/Nodes/AbstractRangeQueryNode.cs    |  83 ++++---
 .../Standard/Nodes/BooleanModifierNode.cs       |   6 +-
 .../Standard/Nodes/MultiPhraseQueryNode.cs      |   4 +-
 .../Flexible/Standard/Nodes/NumericQueryNode.cs |  61 +++--
 .../Standard/Nodes/NumericRangeQueryNode.cs     |  54 ++---
 .../Standard/Nodes/PrefixWildcardQueryNode.cs   |  36 ++-
 .../Flexible/Standard/Nodes/RegexpQueryNode.cs  |  38 ++--
 .../Standard/Nodes/StandardBooleanQueryNode.cs  |   8 +-
 .../Standard/Nodes/TermRangeQueryNode.cs        |  19 +-
 .../Standard/Nodes/WildcardQueryNode.cs         |  36 ++-
 .../Flexible/Standard/Parser/CharStream.cs      | 134 +++++------
 .../Standard/Parser/EscapeQuerySyntaxImpl.cs    |  55 +++--
 .../Flexible/Standard/Parser/FastCharStream.cs  |   8 +-
 .../Flexible/Standard/Parser/ParseException.cs  |  98 ++++----
 .../Standard/Parser/StandardSyntaxParser.cs     |  37 ++--
 .../Parser/StandardSyntaxParserConstants.cs     |   3 +
 .../Parser/StandardSyntaxParserTokenManager.cs  |  22 +-
 .../Flexible/Standard/Parser/Token.cs           | 128 +++++------
 .../Flexible/Standard/Parser/TokenMgrError.cs   | 102 ++++-----
 .../Processors/AllowLeadingWildcardProcessor.cs |   8 +-
 .../Processors/AnalyzerQueryNodeProcessor.cs    |  22 +-
 .../BooleanQuery2ModifierNodeProcessor.cs       |  26 +--
 ...SingleChildOptimizationQueryNodeProcessor.cs |   6 +-
 .../Processors/BoostQueryNodeProcessor.cs       |   6 +-
 .../DefaultPhraseSlopQueryNodeProcessor.cs      |  12 +-
 .../Processors/FuzzyQueryNodeProcessor.cs       |  10 +-
 .../Processors/GroupQueryNodeProcessor.cs       |   6 +-
 .../LowercaseExpandedTermsQueryNodeProcessor.cs |  10 +-
 .../MatchAllDocsQueryNodeProcessor.cs           |   6 +-
 .../Processors/MultiFieldQueryNodeProcessor.cs  |  14 +-
 .../MultiTermRewriteMethodProcessor.cs          |   4 +-
 .../Processors/NumericQueryNodeProcessor.cs     |  30 +--
 .../NumericRangeQueryNodeProcessor.cs           |  22 +-
 .../Processors/OpenRangeQueryNodeProcessor.cs   |   2 +-
 .../Processors/PhraseSlopQueryNodeProcessor.cs  |   6 +-
 .../RemoveEmptyNonLeafQueryNodeProcessor.cs     |   8 +-
 .../StandardQueryNodeProcessorPipeline.cs       |  14 +-
 .../Processors/TermRangeQueryNodeProcessor.cs   |  22 +-
 .../Processors/WildcardQueryNodeProcessor.cs    |   8 +-
 .../Flexible/Standard/QueryParserUtil.cs        | 170 ++++++--------
 .../Flexible/Standard/StandardQueryParser.cs    |  79 ++++++-
 .../Flexible/Spans/SpanOrQueryNodeBuilder.cs    |   1 -
 122 files changed, 1709 insertions(+), 1820 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Builders/QueryTreeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Builders/QueryTreeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Builders/QueryTreeBuilder.cs
index 65f3798..3c9e392 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Builders/QueryTreeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Builders/QueryTreeBuilder.cs
@@ -45,11 +45,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Builders
     /// </para>
     /// <para>
     /// The children are usually built before the parent node. However, if a builder
-    /// associated to a node is an instance of <see cref="QueryTreeBuilder"/>, the node is
+    /// associated to a node is an instance of <see cref="QueryTreeBuilder{TQuery}"/>, the node is
     /// delegated to this builder and it's responsible to build the node and its
     /// children.
     /// </para>
-    /// <seealso cref="IQueryBuilder"/>
+    /// <seealso cref="IQueryBuilder{TQuery}"/>
     /// </summary>
     public class QueryTreeBuilder<TQuery> : QueryTreeBuilder, IQueryBuilder<TQuery>
     {
@@ -57,20 +57,19 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Builders
 
         private IDictionary<string, IQueryBuilder<TQuery>> fieldNameBuilders;
 
-        /**
-         * {@link QueryTreeBuilder} constructor.
-         */
+        /// <summary>
+        /// <see cref="QueryTreeBuilder{TQuery}"/> constructor.
+        /// </summary>
         public QueryTreeBuilder()
         {
             // empty constructor
         }
 
-        /**
-         * Associates a field name with a builder.
-         * 
-         * @param fieldName the field name
-         * @param builder the builder to be associated
-         */
+        /// <summary>
+        /// Associates a field name with a builder.
+        /// </summary>
+        /// <param name="fieldName">the field name</param>
+        /// <param name="builder">the builder to be associated</param>
         public virtual void SetBuilder(string fieldName, IQueryBuilder<TQuery> builder)
         {
 
@@ -82,28 +81,24 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Builders
             this.fieldNameBuilders[fieldName] = builder;
         }
 
-        /**
-         * Associates a class with a builder
-         * 
-         * @param queryNodeClass the class
-         * @param builder the builder to be associated
-         */
+        /// <summary>
+        /// Associates a <see cref="Type">class</see> (that implements <see cref="IQueryNode"/>) with a builder
+        /// </summary>
+        /// <param name="queryNodeClass">The type (a class that implements <see cref="IQueryNode"/>)</param>
+        /// <param name="builder">the builder to be associated</param>
         public virtual void SetBuilder(Type queryNodeClass,
             IQueryBuilder<TQuery> builder)
         {
-
             if (this.queryNodeBuilders == null)
             {
                 this.queryNodeBuilders = new Dictionary<Type, IQueryBuilder<TQuery>>();
             }
 
             this.queryNodeBuilders[queryNodeClass] = builder;
-
         }
 
         private void Process(IQueryNode node)
         {
-
             if (node != null)
             {
                 IQueryBuilder<TQuery> builder = GetBuilder(node);
@@ -119,15 +114,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Builders
                         {
                             Process(child);
                         }
-
                     }
-
                 }
 
                 ProcessNode(node, builder);
-
             }
-
         }
 
         private IQueryBuilder<TQuery> GetBuilder(IQueryNode node)
@@ -199,18 +190,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Builders
             return null;
         }
 
-        /**
-         * Builds some kind of object from a query tree. Each node in the query tree
-         * is built using an specific builder associated to it.
-         * 
-         * @param queryNode the query tree root node
-         * 
-         * @return the built object
-         * 
-         * @throws QueryNodeException if some node builder throws a
-         *         {@link QueryNodeException} or if there is a node which had no
-         *         builder associated to it
-         */
+        /// <summary>
+        /// Builds some kind of object from a query tree. Each node in the query tree
+        /// is built using an specific builder associated to it.
+        /// </summary>
+        /// <param name="queryNode">the query tree root node</param>
+        /// <returns>the built object</returns>
+        /// <exception cref="QueryNodeException">if some node builder throws a 
+        /// <see cref="QueryNodeException"/> or if there is a node which had no
+        /// builder associated to it</exception>
         public virtual TQuery Build(IQueryNode queryNode)
         {
             Process(queryNode);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Config/AbstractQueryConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Config/AbstractQueryConfig.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Config/AbstractQueryConfig.cs
index ad41267..7cdcd09 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Config/AbstractQueryConfig.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Config/AbstractQueryConfig.cs
@@ -21,13 +21,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
      */
 
     /// <summary>
-    /// This class is the base of {@link QueryConfigHandler} and {@link FieldConfig}.
+    /// This class is the base of <see cref="QueryConfigHandler"/> and <see cref="FieldConfig"/>.
     /// It has operations to set, unset and get configuration values.
     /// <para>
     /// Each configuration is is a key->value pair. The key should be an unique
-    /// {@link ConfigurationKey} instance and it also holds the value's type.
+    /// <see cref="ConfigurationKey{T}"/> instance and it also holds the value's type.
     /// </para>
-    /// <seealso cref="ConfigurationKey"/>
+    /// <seealso cref="ConfigurationKey{T}"/>
     /// </summary>
     public abstract class AbstractQueryConfig
     {
@@ -38,15 +38,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
             // although this class is public, it can only be constructed from package
         }
 
-        /**
-         * Returns the value held by the given key.
-         * 
-         * @param <T> the value's type
-         * 
-         * @param key the key, cannot be <code>null</code>
-         * 
-         * @return the value held by the given key
-         */
+        /// <summary>
+        /// Returns the value held by the given key.
+        /// </summary>
+        /// <typeparam name="T">the value's type</typeparam>
+        /// <param name="key">the key, cannot be <c>null</c></param>
+        /// <returns>the value held by the given key</returns>
         public virtual T Get<T>(ConfigurationKey<T> key)
         {
             if (key == null)
@@ -58,13 +55,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
             return result == null ? default(T) : (T)result;
         }
 
-        /**
-         * Returns true if there is a value set with the given key, otherwise false.
-         * 
-         * @param <T> the value's type
-         * @param key the key, cannot be <code>null</code>
-         * @return true if there is a value set with the given key, otherwise false
-         */
+        /// <summary>
+        /// Returns <c>true</c> if there is a value set with the given key, otherwise <c>false</c>.
+        /// </summary>
+        /// <typeparam name="T">the value's type</typeparam>
+        /// <param name="key">the key, cannot be <c>null</c></param>
+        /// <returns><c>true</c> if there is a value set with the given key, otherwise <c>false</c></returns>
         public virtual bool Has<T>(ConfigurationKey<T> key)
         {
             if (key == null)
@@ -75,13 +71,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
             return this.configMap.ContainsKey(key);
         }
 
-        /**
-         * Sets a key and its value.
-         * 
-         * @param <T> the value's type
-         * @param key the key, cannot be <code>null</code>
-         * @param value value to set
-         */
+        /// <summary>
+        /// Sets a key and its value.
+        /// </summary>
+        /// <typeparam name="T">the value's type</typeparam>
+        /// <param name="key">the key, cannot be <c>null</c></param>
+        /// <param name="value">value to set</param>
         public virtual void Set<T>(ConfigurationKey<T> key, T value)
         {
             if (key == null)
@@ -99,13 +94,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
             }
         }
 
-        /**
-         * Unsets the given key and its value.
-         * 
-         * @param <T> the value's type
-         * @param key the key
-         * @return true if the key and value was set and removed, otherwise false
-         */
+        /// <summary>
+        /// Unsets the given key and its value.
+        /// </summary>
+        /// <typeparam name="T">the value's type</typeparam>
+        /// <param name="key">the key</param>
+        /// <returns><c>true</c> if the key and value was set and removed, otherwise <c>false</c></returns>
         public virtual bool Unset<T>(ConfigurationKey<T> key)
         {
             if (key == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Config/ConfigurationKey.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Config/ConfigurationKey.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Config/ConfigurationKey.cs
index a39535e..b3cb6d5 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Config/ConfigurationKey.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Config/ConfigurationKey.cs
@@ -19,11 +19,11 @@
 
     /// <summary>
     /// An instance of this class represents a key that is used to retrieve a value
-    /// from {@link AbstractQueryConfig}. It also holds the value's type, which is
+    /// from <see cref="AbstractQueryConfig"/>. It also holds the value's type, which is
     /// defined in the generic argument.
     /// </summary>
     /// <seealso cref="AbstractQueryConfig"/>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">the value's type</typeparam>
     public sealed class ConfigurationKey<T> : ConfigurationKey
     {
         internal ConfigurationKey() { }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfig.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfig.cs
index 96001e5..04a9c9d 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfig.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfig.cs
@@ -26,12 +26,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
     {
         private string fieldName;
 
-        /**
-         * Constructs a {@link FieldConfig}
-         * 
-         * @param fieldName the field name, it cannot be null
-         * @throws IllegalArgumentException if the field name is null
-         */
+        /// <summary>
+        /// Constructs a <see cref="FieldConfig"/>
+        /// </summary>
+        /// <param name="fieldName">the field name, it cannot be null</param>
+        /// <exception cref="ArgumentException">if the field name is null</exception>
         public FieldConfig(string fieldName)
         {
             if (fieldName == null)
@@ -42,11 +41,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
             this.fieldName = fieldName;
         }
 
-        /**
-         * Returns the field name this configuration represents.
-         * 
-         * @return the field name
-         */
+        /// <summary>
+        /// Gets the field name this configuration represents.
+        /// </summary>
         public virtual string Field
         {
             get { return this.fieldName; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfigListener.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfigListener.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfigListener.cs
index 1e50e32..7481175 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfigListener.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Config/FieldConfigListener.cs
@@ -20,14 +20,14 @@
     /// <summary>
     /// This interface should be implemented by classes that wants to listen for
     /// field configuration requests. The implementation receives a
-    /// {@link FieldConfig} object and may add/change its configuration.
+    /// <see cref="FieldConfig"/> object and may add/change its configuration.
     /// </summary>
     /// <seealso cref="FieldConfig"/>
     /// <seealso cref="QueryConfigHandler"/>
     public interface IFieldConfigListener
     {
         /// <summary>
-        /// This method is called ever time a field configuration is requested.
+        /// This method is called every time a field configuration is requested.
         /// </summary>
         /// <param name="fieldConfig">the field configuration requested, should never be null</param>
         void BuildFieldConfig(FieldConfig fieldConfig);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Config/QueryConfigHandler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Config/QueryConfigHandler.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Config/QueryConfigHandler.cs
index 629dc76..1b15b12 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Config/QueryConfigHandler.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Config/QueryConfigHandler.cs
@@ -23,15 +23,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
     /// <summary>
     /// This class can be used to hold any query configuration and no field
     /// configuration. For field configuration, it creates an empty
-    /// {@link FieldConfig} object and delegate it to field config listeners, 
+    /// <see cref="FieldConfig"/> object and delegate it to field config listeners, 
     /// these are responsible for setting up all the field configuration.
     /// <para>
-    /// {@link QueryConfigHandler} should be extended by classes that intends to
-    /// provide configuration to {@link QueryNodeProcessor} objects.
+    /// <see cref="QueryConfigHandler"/> should be extended by classes that intends to
+    /// provide configuration to <see cref="Processors.IQueryNodeProcessor"/> objects.
     /// </para>
     /// <para>
-    /// The class that extends {@link QueryConfigHandler} should also provide
-    /// {@link FieldConfig} objects for each collection field.
+    /// The class that extends <see cref="QueryConfigHandler"/> should also provide
+    /// <see cref="FieldConfig"/> objects for each collection field.
     /// </para>
     /// </summary>
     /// <seealso cref="FieldConfig"/>
@@ -41,19 +41,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
     {
         private readonly LinkedList<IFieldConfigListener> listeners = new LinkedList<IFieldConfigListener>();
 
-        /**
-         * Returns an implementation of
-         * {@link FieldConfig} for a specific field name. If the implemented
-         * {@link QueryConfigHandler} does not know a specific field name, it may
-         * return <code>null</code>, indicating there is no configuration for that
-         * field.
-         * 
-         * @param fieldName
-         *          the field name
-         * @return a {@link FieldConfig} object containing the field name
-         *         configuration or <code>null</code>, if the implemented
-         *         {@link QueryConfigHandler} has no configuration for that field
-         */
+        /// <summary>
+        /// Returns an implementation of
+        /// <see cref="FieldConfig"/> for a specific field name. If the implemented
+        /// <see cref="QueryConfigHandler"/> does not know a specific field name, it may
+        /// return <c>null</c>, indicating there is no configuration for that
+        /// field.
+        /// </summary>
+        /// <param name="fieldName">the field name</param>
+        /// <returns>A <see cref="FieldConfig"/>object containing the field name
+        /// configuration or <c>null</c>, if the implemented
+        /// <see cref="QueryConfigHandler"/> has no configuration for that field</returns>
         public virtual FieldConfig GetFieldConfig(string fieldName)
         {
             FieldConfig fieldConfig = new FieldConfig(StringUtils.ToString(fieldName));
@@ -67,13 +65,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Config
 
         }
 
-        /**
-         * Adds a listener. The added listeners are called in the order they are
-         * added.
-         * 
-         * @param listener
-         *          the listener to be added
-         */
+        /// <summary>
+        /// Adds a listener. The added listeners are called in the order they are
+        /// added.
+        /// </summary>
+        /// <param name="listener">the listener to be added</param>
         public virtual void AddFieldConfigListener(IFieldConfigListener listener)
         {
             this.listeners.AddLast(listener);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AndQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AndQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AndQueryNode.cs
index 1dd7f32..4fccebb 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AndQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AndQueryNode.cs
@@ -23,15 +23,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link AndQueryNode} represents an AND boolean operation performed on a
+    /// A <see cref="AndQueryNode"/> represents an AND boolean operation performed on a
     /// list of nodes.
     /// </summary>
     public class AndQueryNode : BooleanQueryNode
     {
-        /**
-   * @param clauses
-   *          - the query nodes to be and'ed
-   */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">the query nodes to be and'ed</param>
         public AndQueryNode(IList<IQueryNode> clauses)
             : base(clauses)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AnyQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AnyQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AnyQueryNode.cs
index ac04755..96f3f38 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AnyQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/AnyQueryNode.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link AnyQueryNode} represents an ANY operator performed on a list of
+    /// A <see cref="AnyQueryNode"/> represents an ANY operator performed on a list of
     /// nodes.
     /// </summary>
     public class AnyQueryNode : AndQueryNode
@@ -30,10 +30,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         private string field = null;
         private int minimumMatchingmElements = 0;
 
-        /**
-         * @param clauses
-         *          - the query nodes to be or'ed
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">the query nodes to be or'ed</param>
+        /// <param name="field"></param>
+        /// <param name="minimumMatchingElements"></param>
         public AnyQueryNode(IList<IQueryNode> clauses, string field,
             int minimumMatchingElements)
             : base(clauses)
@@ -78,11 +80,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
         // LUCENENET TODO: No need for GetFieldAsString method because
         // field is already type string
-        /**
-         * returns - null if the field was not specified
-         * 
-         * @return the field as a String
-         */
+        /// <summary>
+        /// null if the field was not specified
+        /// </summary>
+        /// <returns>the field as a <see cref="string"/></returns>
         public virtual string GetFieldAsString()
         {
             if (this.field == null)
@@ -101,7 +102,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return clone;
         }
 
-
         public override string ToString()
         {
             var children = GetChildren();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BooleanQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BooleanQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BooleanQueryNode.cs
index 2976640..8017681 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BooleanQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BooleanQueryNode.cs
@@ -22,16 +22,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link BooleanQueryNode} represents a list of elements which do not have an
+    /// A <see cref="BooleanQueryNode"/> represents a list of elements which do not have an
     /// explicit boolean operator defined between them. It can be used to express a
     /// boolean query that intends to use the default boolean operator.
     /// </summary>
     public class BooleanQueryNode : QueryNodeImpl
     {
-        /**
-        * @param clauses
-        *          - the query nodes to be and'ed
-        */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">the query nodes to be and'ed</param>
         public BooleanQueryNode(IList<IQueryNode> clauses)
         {
             IsLeaf = false;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BoostQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BoostQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BoostQueryNode.cs
index 3bd4bc8..e324a8c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BoostQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/BoostQueryNode.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link BoostQueryNode} boosts the QueryNode tree which is under this node.
+    /// A <see cref="BoostQueryNode"/> boosts the QueryNode tree which is under this node.
     /// So, it must only and always have one child.
     /// 
     /// The boost value may vary from 0.0 to 1.0.
@@ -32,14 +32,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
     {
         private float value = 0;
 
-        /**
-         * Constructs a boost node
-         * 
-         * @param query
-         *          the query to be boosted
-         * @param value
-         *          the boost value, it may vary from 0.0 to 1.0
-         */
+        /// <summary>
+        /// Constructs a boost node
+        /// </summary>
+        /// <param name="query">the query to be boosted</param>
+        /// <param name="value">the boost value, it may vary from 0.0 to 1.0</param>
         public BoostQueryNode(IQueryNode query, float value)
         {
             if (query == null)
@@ -54,11 +51,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             Add(query);
         }
 
-        /**
-         * Returns the single child which this node boosts.
-         * 
-         * @return the single child which this node boosts
-         */
+        /// <summary>
+        /// Gets the single child which this node boosts.
+        /// </summary>
         public virtual IQueryNode Child
         {
             get
@@ -74,21 +69,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             }
         }
 
-        /**
-         * Returns the boost value. It may vary from 0.0 to 1.0.
-         * 
-         * @return the boost value
-         */
+        /// <summary>
+        /// Gets the boost value. It may vary from 0.0 to 1.0.
+        /// </summary>
         public virtual float Value
         {
             get { return this.value; }
         }
 
-        /**
-         * Returns the boost value parsed to a string.
-         * 
-         * @return the parsed value
-         */
+        /// <summary>
+        /// Returns the boost value parsed to a string.
+        /// </summary>
+        /// <returns>the parsed value</returns>
         private string GetValueString()
         {
             float f = this.value;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/DeletedQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/DeletedQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/DeletedQueryNode.cs
index a47ce40..f1b1f69 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/DeletedQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/DeletedQueryNode.cs
@@ -20,9 +20,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link DeletedQueryNode} represents a node that was deleted from the query
+    /// A <see cref="DeletedQueryNode"/> represents a node that was deleted from the query
     /// node tree. It can be removed from the tree using the
-    /// {@link RemoveDeletedQueryNodesProcessor} processor.
+    /// <see cref="Processors.RemoveDeletedQueryNodesProcessor"/> processor.
     /// </summary>
     public class DeletedQueryNode : QueryNodeImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldQueryNode.cs
index 522c783..8b05f5a 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldQueryNode.cs
@@ -22,45 +22,42 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link FieldQueryNode} represents a element that contains field/text tuple
+    /// A <see cref="FieldQueryNode"/> represents a element that contains field/text tuple
     /// </summary>
     public class FieldQueryNode : QueryNodeImpl, IFieldValuePairQueryNode<string>, ITextableQueryNode
     {
-        /**
-   * The term's field
-   */
+        /// <summary>
+        /// The term's field
+        /// </summary>
         protected string field;
 
-        /**
-         * The term's text.
-         */
+        /// <summary>
+        /// The term's text.
+        /// </summary>
         protected ICharSequence text;
 
-        /**
-         * The term's begin position.
-         */
+        /// <summary>
+        /// The term's begin position.
+        /// </summary>
         protected int begin;
 
-        /**
-         * The term's end position.
-         */
+        /// <summary>
+        /// The term's end position.
+        /// </summary>
         protected int end;
 
-        /**
-         * The term's position increment.
-         */
+        /// <summary>
+        /// The term's position increment.
+        /// </summary>
         protected int positionIncrement;
 
-        /**
-         * @param field
-         *          - field name
-         * @param text
-         *          - value
-         * @param begin
-         *          - position in the query string
-         * @param end
-         *          - position in the query string
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">field name</param>
+        /// <param name="text">value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
          // LUCENENET specific overload for passing text as string
         public FieldQueryNode(string field, string text, int begin,
             int end)
@@ -68,16 +65,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         {
         }
 
-        /**
-         * @param field
-         *          - field name
-         * @param text
-         *          - value
-         * @param begin
-         *          - position in the query string
-         * @param end
-         *          - position in the query string
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">field name</param>
+        /// <param name="text">value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public FieldQueryNode(string field, ICharSequence text, int begin,
             int end)
         {
@@ -119,9 +113,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
                 + this.field + "' text='" + this.text + "'/>";
         }
 
-        /**
-         * @return the term
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns>the term</returns>
         public virtual string GetTextAsString()
         {
             if (this.text == null)
@@ -131,11 +126,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         }
 
         // LUCENENET TODO: this method is not required because Field is already type string in .NET
-        /**
-         * returns null if the field was not specified in the query string
-         * 
-         * @return the field
-         */
+        /// <summary>
+        /// null if the field was not specified in the query string
+        /// </summary>
+        /// <returns>the field</returns>
         public virtual string GetFieldAsString()
         {
             if (this.field == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldValuePairQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldValuePairQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldValuePairQueryNode.cs
index 799dcfa..37da94b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldValuePairQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldValuePairQueryNode.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    /// This interface should be implemented by {@link QueryNode} that holds a field
+    /// This interface should be implemented by <see cref="IQueryNode"/> that holds a field
     /// and an arbitrary value.
     /// </summary>
     /// <seealso cref="IFieldableNode"/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldableNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldableNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldableNode.cs
index a81fa2c..344565b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldableNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FieldableNode.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    /// A query node implements {@link FieldableNode} interface to indicate that its
+    /// A query node implements <see cref="IFieldableNode"/> interface to indicate that its
     /// children and itself are associated to a specific field.
     /// 
     /// If it has any children which also implements this interface, it must ensure

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FuzzyQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FuzzyQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FuzzyQueryNode.cs
index ae619d9..8ba52a6 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FuzzyQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/FuzzyQueryNode.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link FuzzyQueryNode} represents a element that contains
+    /// A <see cref="FuzzyQueryNode"/> represents a element that contains
     /// field/text/similarity tuple
     /// </summary>
     public class FuzzyQueryNode : FieldQueryNode
@@ -30,24 +30,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
         private int prefixLength;
 
-        /**
-         * @param field
-         *          Name of the field query will use.
-         * @param termStr
-         *          Term token to use for building term for the query
-         */
-        /**
-         * @param field
-         *          - Field name
-         * @param term
-         *          - Value
-         * @param minSimilarity
-         *          - similarity value
-         * @param begin
-         *          - position in the query string
-         * @param end
-         *          - position in the query string
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">Name of the field query will use.</param>
+        /// <param name="term">Term token to use for building term for the query</param>
+        /// <param name="minSimilarity">similarity value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
          // LUCENENET specific overload for string term
         public FuzzyQueryNode(string field, string term,
             float minSimilarity, int begin, int end)
@@ -55,18 +45,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         {
         }
 
-        /**
-         * @param field
-         *          - Field name
-         * @param term
-         *          - Value
-         * @param minSimilarity
-         *          - similarity value
-         * @param begin
-         *          - position in the query string
-         * @param end
-         *          - position in the query string
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">Name of the field query will use.</param>
+        /// <param name="term">Term token to use for building term for the query</param>
+        /// <param name="minSimilarity">similarity value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public FuzzyQueryNode(string field, ICharSequence term,
             float minSimilarity, int begin, int end)
             : base(field, term, begin, end)
@@ -99,9 +85,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
                 + "' term='" + this.text + "'/>";
         }
 
-        /**
-         * @return the similarity
-         */
+        /// <summary>
+        /// Gets or Sets the similarity
+        /// </summary>
         public virtual float Similarity
         {
             get { return this.similarity; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/GroupQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/GroupQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/GroupQueryNode.cs
index 915366e..d2c8f43 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/GroupQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/GroupQueryNode.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link GroupQueryNode} represents a location where the original user typed
+    /// A <see cref="GroupQueryNode"/> represents a location where the original user typed
     /// real parenthesis on the query string. This class is useful for queries like:
     /// a) a AND b OR c b) ( a AND b) OR c
     /// 
@@ -31,9 +31,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
     /// </summary>
     public class GroupQueryNode : QueryNodeImpl
     {
-        /**
-   * This QueryNode is used to identify parenthesis on the original query string
-   */
+        /// <summary>
+        /// This IQueryNode is used to identify parenthesis on the original query string
+        /// </summary>
         public GroupQueryNode(IQueryNode query)
         {
             if (query == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchAllDocsQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchAllDocsQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchAllDocsQueryNode.cs
index 6709104..71db0bf 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchAllDocsQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchAllDocsQueryNode.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link MatchAllDocsQueryNode} indicates that a query node tree or subtree
+    /// A <see cref="MatchAllDocsQueryNode"/> indicates that a query node tree or subtree
     /// will match all documents if executed in the index.
     /// </summary>
     public class MatchAllDocsQueryNode : QueryNodeImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchNoDocsQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchNoDocsQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchNoDocsQueryNode.cs
index 1b7a4b7..edbb1d5 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchNoDocsQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/MatchNoDocsQueryNode.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    /// A {@link MatchNoDocsQueryNode} indicates that a query node tree or subtree
+    /// A <see cref="MatchNoDocsQueryNode"/> indicates that a query node tree or subtree
     /// will not match any documents if executed in the index.
     /// </summary>
     public class MatchNoDocsQueryNode : DeletedQueryNode

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ModifierQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ModifierQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ModifierQueryNode.cs
index 5311a1e..2962403 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ModifierQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ModifierQueryNode.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link ModifierQueryNode} indicates the modifier value (+,-,?,NONE) for
+    /// A <see cref="ModifierQueryNode"/> indicates the modifier value (+,-,?,NONE) for
     /// each term on the query string. For example "+t1 -t2 t3" will have a tree of:
     /// <blockquote>
     /// &lt;BooleanQueryNode&gt; &lt;ModifierQueryNode modifier="MOD_REQ"&gt; &lt;t1/&gt;
@@ -38,14 +38,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
         private Modifier modifier = Nodes.Modifier.MOD_NONE;
 
-        /**
-         * Used to store the modifier value on the original query string
-         * 
-         * @param query
-         *          - QueryNode subtree
-         * @param mod
-         *          - Modifier Value
-         */
+        /// <summary>
+        /// Used to store the modifier value on the original query string
+        /// </summary>
+        /// <param name="query">QueryNode subtree</param>
+        /// <param name="mod">Modifier Value</param>
         public ModifierQueryNode(IQueryNode query, Modifier mod)
         {
             if (query == null)
@@ -70,14 +67,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             get { return this.modifier; }
         }
 
-
         public override string ToString()
         {
             return "<modifier operation='" + this.modifier.ToString() + "'>" + "\n"
                 + GetChild().ToString() + "\n</modifier>";
         }
 
-
         public override string ToQueryString(IEscapeQuerySyntax escapeSyntaxParser)
         {
             if (GetChild() == null)
@@ -104,7 +99,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             }
         }
 
-
         public override IQueryNode CloneTree()
         {
             ModifierQueryNode clone = (ModifierQueryNode)base.CloneTree();
@@ -122,9 +116,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         }
     }
 
-    /**
-   * Modifier type: such as required (REQ), prohibited (NOT)
-   */
+    /// <summary>
+    /// Modifier type: such as required (REQ), prohibited (NOT)
+    /// </summary>
     public enum Modifier
     {
         MOD_NONE,

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/NoTokenFoundQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/NoTokenFoundQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/NoTokenFoundQueryNode.cs
index 7914799..8a09c28 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/NoTokenFoundQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/NoTokenFoundQueryNode.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link NoTokenFoundQueryNode} is used if a term is convert into no tokens
+    /// A <see cref="NoTokenFoundQueryNode"/> is used if a term is convert into no tokens
     /// by the tokenizer/lemmatizer/analyzer (null).
     /// </summary>
     public class NoTokenFoundQueryNode : DeletedQueryNode

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OpaqueQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OpaqueQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OpaqueQueryNode.cs
index 9d32332..6df9c15 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OpaqueQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OpaqueQueryNode.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link OpaqueQueryNode} is used for specify values that are not supposed to
+    /// A <see cref="OpaqueQueryNode"/> is used for specify values that are not supposed to
     /// be parsed by the parser. For example: and XPATH query in the middle of a
     /// query string a b @xpath:'/bookstore/book[1]/title' c d
     /// </summary>
@@ -30,12 +30,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
         private string value = null;
 
-        /**
-         * @param schema
-         *          - schema identifier
-         * @param value
-         *          - value that was not parsed
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="schema">schema identifier</param>
+        /// <param name="value">value that was not parsed</param>
         public OpaqueQueryNode(string schema, string value)
         {
             this.IsLeaf = true;
@@ -64,17 +63,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return clone;
         }
 
-        /**
-         * @return the schema
-         */
+        /// <summary>
+        /// Gets the schema
+        /// </summary>
         public virtual string Schema
         {
             get { return this.schema; }
         }
 
-        /**
-         * @return the value
-         */
+        /// <summary>
+        /// Gets the value
+        /// </summary>
         public virtual string Value
         {
             get { return this.value; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OrQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OrQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OrQueryNode.cs
index 93a8e33..0a9b9e0 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OrQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/OrQueryNode.cs
@@ -23,15 +23,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link OrQueryNode} represents an OR boolean operation performed on a list
+    /// A <see cref="OrQueryNode"/> represents an OR boolean operation performed on a list
     /// of nodes.
     /// </summary>
     public class OrQueryNode : BooleanQueryNode
     {
-        /**
-   * @param clauses
-   *          - the query nodes to be or'ed
-   */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">the query nodes to be or'ed</param>
         public OrQueryNode(IList<IQueryNode> clauses)
             : base(clauses)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PathQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PathQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PathQueryNode.cs
index 794fff5..1027efa 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PathQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PathQueryNode.cs
@@ -25,47 +25,45 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link PathQueryNode} is used to store queries like
+    /// A <see cref="PathQueryNode"/> is used to store queries like
     /// /company/USA/California /product/shoes/brown. QueryText are objects that
     /// contain the text, begin position and end position in the query.
     /// <para>
     /// Example how the text parser creates these objects:
     /// </para>
     /// <code>
-    /// List values = new List();
-    /// values.add(new PathQueryNode.QueryText("company", 1, 7));
-    /// values.add(new PathQueryNode.QueryText("USA", 9, 12));
-    /// values.add(new PathQueryNode.QueryText("California", 14, 23));
+    /// IList&lt;PathQueryNode.QueryText&gt; values = new List&lt;PathQueryNode.QueryText&gt;();
+    /// values.Add(new PathQueryNode.QueryText("company", 1, 7));
+    /// values.Add(new PathQueryNode.QueryText("USA", 9, 12));
+    /// values.Add(new PathQueryNode.QueryText("California", 14, 23));
     /// QueryNode q = new PathQueryNode(values);
     /// </code>
-    /// 
     /// </summary>
     public class PathQueryNode : QueryNodeImpl
     {
-        /**
-   * Term text with a beginning and end position
-   */
+        /// <summary>
+        /// Term text with a beginning and end position
+        /// </summary>
         public class QueryText : ICloneable
         {
             private string value = null;
-            /**
-             * != null The term's begin position.
-             */
+
+            /// <summary>
+            /// != null The term's begin position.
+            /// </summary>
             private int begin;
 
-            /**
-             * The term's end position.
-             */
+            /// <summary>
+            /// The term's end position.
+            /// </summary>
             private int end;
 
-            /**
-             * @param value
-             *          - text value
-             * @param begin
-             *          - position in the query string
-             * @param end
-             *          - position in the query string
-             */
+            /// <summary>
+            /// 
+            /// </summary>
+            /// <param name="value">text value</param>
+            /// <param name="begin">position in the query string</param>
+            /// <param name="end">position in the query string</param>
             public QueryText(string value, int begin, int end)
                 : base()
             {
@@ -84,25 +82,25 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
                 return clone;
             }
 
-            /**
-             * @return the value
-             */
+            /// <summary>
+            /// Gets the value
+            /// </summary>
             public virtual string Value
             {
                 get { return value; }
             }
 
-            /**
-             * @return the begin
-             */
+            /// <summary>
+            /// Gets the begin
+            /// </summary>
             public virtual int Begin
             {
                 get { return begin; }
             }
 
-            /**
-             * @return the end
-             */
+            /// <summary>
+            /// Gets the end
+            /// </summary>
             public virtual int End
             {
                 get { return end; }
@@ -116,10 +114,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
         private IList<QueryText> values = null;
 
-        /**
-         * @param pathElements
-         *          - List of QueryText objects
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pathElements">List of QueryText objects</param>
         public PathQueryNode(IList<QueryText> pathElements)
         {
             this.values = pathElements;
@@ -141,31 +139,30 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             set { this.values = value; }
         }
 
-        /**
-         * Returns the a specific QueryText element
-         * 
-         * @return QueryText List size
-         */
+        /// <summary>
+        /// Returns the a specific QueryText element
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns>QueryText List size</returns>
         public virtual QueryText GetPathElement(int index)
         {
             return values[index];
         }
 
-        /**
-         * Returns the CharSequence value of a specific QueryText element
-         * 
-         * @return the CharSequence for a specific QueryText element
-         */
+        /// <summary>
+        /// Returns the <see cref="string"/> value of a specific QueryText element
+        /// </summary>
+        /// <returns>The <see cref="string"/> for a specific QueryText element</returns>
         public virtual string GetFirstPathElement()
         {
             return values[0].Value;
         }
 
-        /**
-         * Returns a List QueryText element from position startIndex
-         * 
-         * @return a List QueryText element from position startIndex
-         */
+        /// <summary>
+        /// Returns a List QueryText element from position <paramref name="startIndex"/> 
+        /// </summary>
+        /// <param name="startIndex"></param>
+        /// <returns>a List QueryText element from position <paramref name="startIndex"/></returns>
         public virtual IList<QueryText> GetPathElements(int startIndex)
         {
             List<PathQueryNode.QueryText> rValues = new List<PathQueryNode.QueryText>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PhraseSlopQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PhraseSlopQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PhraseSlopQueryNode.cs
index f16a59a..76f436b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PhraseSlopQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/PhraseSlopQueryNode.cs
@@ -22,15 +22,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
 
      */
     /// <summary>
-    /// Query node for <see cref="PhraseQuery"/>'s slop factor.
+    /// Query node for <see cref="Search.PhraseQuery"/>'s slop factor.
     /// </summary>
     public class PhraseSlopQueryNode : QueryNodeImpl, IFieldableNode
     {
         private int value = 0;
 
-        /**
-         * @exception QueryNodeError throw in overridden method to disallow
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="value"></param>
+        /// <exception cref="QueryNodeError">throw in overridden method to disallow</exception>
         public PhraseSlopQueryNode(IQueryNode query, int value)
         {
             if (query == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ProximityQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ProximityQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ProximityQueryNode.cs
index ceccf1c..4aa8d70 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ProximityQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ProximityQueryNode.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link ProximityQueryNode} represents a query where the terms should meet
+    /// A <see cref="ProximityQueryNode"/> represents a query where the terms should meet
     /// specific distance conditions. (a b c) WITHIN [SENTENCE|PARAGRAPH|NUMBER]
     /// [INORDER] ("a" "b" "c") WITHIN [SENTENCE|PARAGRAPH|NUMBER] [INORDER]
     /// 
@@ -33,9 +33,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
     /// </summary>
     public class ProximityQueryNode : BooleanQueryNode
     {
-        /**
-   * Distance condition: PARAGRAPH, SENTENCE, or NUMBER
-   */
+        /// <summary>
+        /// Distance condition: PARAGRAPH, SENTENCE, or NUMBER
+        /// </summary>
         public enum Type
         {
             PARAGRAPH,
@@ -51,19 +51,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         private bool inorder = false;
         private string field = null;
 
-        /**
-         * @param clauses
-         *          - QueryNode children
-         * @param field
-         *          - field name
-         * @param type
-         *          - type of proximity query
-         * @param distance
-         *          - positive integer that specifies the distance
-         * @param inorder
-         *          - true, if the tokens should be matched in the order of the
-         *          clauses
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">QueryNode children</param>
+        /// <param name="field">field name</param>
+        /// <param name="type">type of proximity query</param>
+        /// <param name="distance">positive integer that specifies the distance</param>
+        /// <param name="inorder">true, if the tokens should be matched in the order of the clauses</param>
         public ProximityQueryNode(IList<IQueryNode> clauses, string field,
             ProximityQueryNode.Type type, int distance, bool inorder)
             : base(clauses)
@@ -88,17 +83,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             ClearFields(clauses, field);
         }
 
-        /**
-         * @param clauses
-         *          - QueryNode children
-         * @param field
-         *          - field name
-         * @param type
-         *          - type of proximity query
-         * @param inorder
-         *          - true, if the tokens should be matched in the order of the
-         *          clauses
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="clauses">QueryNode children</param>
+        /// <param name="field">field name</param>
+        /// <param name="type">type of proximity query</param>
+        /// <param name="inorder">true, if the tokens should be matched in the order of the clauses</param>
         public ProximityQueryNode(IList<IQueryNode> clauses, string field,
             ProximityQueryNode.Type type, bool inorder)
             : this(clauses, field, type, -1, inorder)
@@ -190,19 +181,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return clone;
         }
 
-        /**
-         * @return the distance
-         */
+        /// <summary>
+        /// Gets the distance
+        /// </summary>
         public virtual int Distance
         {
             get { return this.distance; }
         }
 
-        /**
-         * returns null if the field was not specified in the query string
-         * 
-         * @return the field
-         */
+        /// <summary>
+        /// Gets or Sets the field. Returns null if the field was not specified in the query string.
+        /// </summary>
         public virtual string Field
         {
             get { return this.field; }
@@ -210,11 +199,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         }
 
         // LUCENENET TODO: This method is not required because Field is already a string property
-        /**
-         * returns null if the field was not specified in the query string
-         * 
-         * @return the field
-         */
+        /// <summary>
+        /// Gets the field as a string. Returns null if the field was not specified in the query string.
+        /// </summary>
+        /// <returns></returns>
         public virtual string GetFieldAsString()
         {
             if (this.field == null)
@@ -223,16 +211,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
                 return this.field.ToString();
         }
 
-        /**
-         * @return terms must be matched in the specified order
-         */
+        /// <summary>
+        /// terms must be matched in the specified order
+        /// </summary>
         public virtual bool IsInOrder
         {
             get { return this.inorder; }
         }
     }
 
-    /** utility class containing the distance condition and number */
+    /// <summary>
+    /// utility class containing the distance condition and number
+    /// </summary>
     public class ProximityType
     {
         internal int pDistance = 0;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNode.cs
index a448d10..a42b93c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNode.cs
@@ -21,75 +21,86 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link QueryNode} is a interface implemented by all nodes on a QueryNode
+    /// A <see cref="IQueryNode"/> is a interface implemented by all nodes on a <see cref="IQueryNode"/>
     /// tree.
     /// </summary>
     public interface IQueryNode
     {
-        /** convert to a query string understood by the query parser */
+        /// <summary>
+        /// convert to a query string understood by the query parser
+        /// </summary>
         // TODO: this interface might be changed in the future
         string ToQueryString(IEscapeQuerySyntax escapeSyntaxParser);
 
-        /** for printing */
+        /// <summary>
+        /// for printing
+        /// </summary>
         string ToString();
 
-        /** get Children nodes */
+        /// <summary>
+        /// get Children nodes
+        /// </summary>
         IList<IQueryNode> GetChildren();
 
-        /** verify if a node is a Leaf node */
+        /// <summary>
+        /// verify if a node is a Leaf node
+        /// </summary>
         bool IsLeaf { get; }
 
-        /** verify if a node contains a tag */
+        /// <summary>
+        /// verify if a node contains a tag
+        /// </summary>
         bool ContainsTag(string tagName);
 
-        /**
-         * Returns object stored under that tag name
-         */
+        /// <summary>
+        /// Returns object stored under that tag name
+        /// </summary>
         object GetTag(string tagName);
 
         IQueryNode Parent { get; }
 
-        /**
-         * Recursive clone the QueryNode tree The tags are not copied to the new tree
-         * when you call the cloneTree() method
-         * 
-         * @return the cloned tree
-         */
+        /// <summary>
+        /// Recursive clone the <see cref="IQueryNode"/> tree. The tags are not copied to the new tree
+        /// when you call the <see cref="CloneTree()"/> method.
+        /// </summary>
+        /// <returns>the cloned tree</returns>
         IQueryNode CloneTree();
 
         // Below are the methods that can change state of a QueryNode
         // Write Operations (not Thread Safe)
 
-        // add a new child to a non Leaf node
+        /// <summary>
+        /// add a new child to a non Leaf node
+        /// </summary>
         void Add(IQueryNode child);
 
         void Add(IList<IQueryNode> children);
 
-        // reset the children of a node
+        /// <summary>
+        /// reset the children of a node
+        /// </summary>
         void Set(IList<IQueryNode> children);
 
-        /**
-         * Associate the specified value with the specified tagName. If the tagName
-         * already exists, the old value is replaced. The tagName and value cannot be
-         * null. tagName will be converted to lowercase.
-         */
+        /// <summary>
+        /// Associate the specified value with the specified <paramref name="tagName"/>. If the <paramref name="tagName"/>
+        /// already exists, the old value is replaced. The <paramref name="tagName"/> and <paramref name="value"/> cannot be
+        /// null. <paramref name="tagName"/> will be converted to lowercase.
+        /// </summary>
         void SetTag(string tagName, object value);
 
-        /**
-         * Unset a tag. tagName will be converted to lowercase.
-         */
+        /// <summary>
+        /// Unset a tag. <paramref name="tagName"/> will be converted to lowercase.
+        /// </summary>
         void UnsetTag(string tagName);
 
-        /**
-         * Returns a map containing all tags attached to this query node. 
-         * 
-         * @return a map containing all tags attached to this query node
-         */
+        /// <summary>
+        /// Gets a map containing all tags attached to this query node. 
+        /// </summary>
         IDictionary<string, object> TagMap { get; }
 
-        /**
-         * Removes this query node from its parent.
-         */
+        /// <summary>
+        /// Removes this query node from its parent.
+        /// </summary>
         void RemoveFromParent();
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
index b0a08ec..c3c3dcc 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QueryNodeImpl.cs
@@ -27,12 +27,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link QueryNodeImpl} is the default implementation of the interface
-    /// {@link QueryNode}
+    /// A <see cref="QueryNodeImpl"/> is the default implementation of the interface
+    /// <see cref="IQueryNode"/>
     /// </summary>
     public abstract class QueryNodeImpl : IQueryNode, ICloneable
     {
-        /* index default field */
+        /// <summary>
+        /// index default field
+        /// </summary>
         // TODO remove PLAINTEXT_FIELD_NAME replacing it with configuration APIs
         public static readonly string PLAINTEXT_FIELD_NAME = "_plain";
 
@@ -144,10 +146,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return CloneTree();
         }
 
-        /**
-         * @return a List for QueryNode object. Returns null, for nodes that do not
-         *         contain children. All leaf Nodes return null.
-         */
+        /// <summary>
+        /// a List for QueryNode object. Returns null, for nodes that do not
+        /// contain children. All leaf Nodes return null.
+        /// </summary>
         public IList<IQueryNode> GetChildren()
         {
             if (IsLeaf || this.clauses == null)
@@ -167,7 +169,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             this.tags.Remove(tagName.ToLower(CultureInfo.InvariantCulture));
         }
 
-        /** verify if a node contains a tag */
+        /// <summary>
+        /// verify if a node contains a tag
+        /// </summary>
         public virtual bool ContainsTag(string tagName)
         {
             return this.tags.ContainsKey(tagName.ToLower(CultureInfo.InvariantCulture));
@@ -199,17 +203,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             get { return Parent == null; }
         }
 
-        /**
-         * If set to true the the method toQueryString will not write field names
-         */
+        /// <summary>
+        /// If set to true the the method toQueryString will not write field names
+        /// </summary>
         protected internal bool toQueryStringIgnoreFields = false;
 
-        /**
-         * This method is use toQueryString to detect if fld is the default field
-         * 
-         * @param fld - field name
-         * @return true if fld is the default field
-         */
+        /// <summary>
+        /// This method is use toQueryString to detect if fld is the default field
+        /// </summary>
+        /// <param name="fld">field name</param>
+        /// <returns>true if fld is the default field</returns>
         // TODO: remove this method, it's commonly used by {@link
         // #toQueryString(org.apache.lucene.queryParser.core.parser.EscapeQuerySyntax)}
         // to figure out what is the default field, however, {@link
@@ -226,23 +229,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
             return false;
         }
 
-        /**
-         * Every implementation of this class should return pseudo xml like this:
-         * 
-         * For FieldQueryNode: &lt;field start='1' end='2' field='subject' text='foo'/&gt;
-         * 
-         * @see org.apache.lucene.queryparser.flexible.core.nodes.QueryNode#toString()
-         */
+        /// <summary>
+        /// Every implementation of this class should return pseudo xml like this:
+        /// 
+        /// For FieldQueryNode: &lt;field start='1' end='2' field='subject' text='foo'/&gt;
+        /// </summary>
+        /// <seealso cref="IQueryNode.ToString()"/>
         public override string ToString()
         {
             return base.ToString();
         }
 
-        /**
-         * Returns a map containing all tags attached to this query node.
-         * 
-         * @return a map containing all tags attached to this query node
-         */
+        /// <summary>
+        /// Gets a map containing all tags attached to this query node.
+        /// </summary>
         public virtual IDictionary<string, object> TagMap
         {
             get { return new Dictionary<string, object>(this.tags); }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QuotedFieldQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QuotedFieldQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QuotedFieldQueryNode.cs
index d4d9d8f..c3111c0 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QuotedFieldQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/QuotedFieldQueryNode.cs
@@ -21,21 +21,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link QuotedFieldQueryNode} represents phrase query. Example:
+    /// A <see cref="QuotedFieldQueryNode"/> represents phrase query. Example:
     /// "life is great"
     /// </summary>
     public class QuotedFieldQueryNode : FieldQueryNode
     {
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value
-        * @param begin
-        *          - position in the query string
-        * @param end
-        *          - position in the query string
-        */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">field name</param>
+        /// <param name="text">value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         // LUCENENET specific overload for text string
         public QuotedFieldQueryNode(string field, string text, int begin,
             int end)
@@ -43,16 +40,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
         {
         }
 
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value
-        * @param begin
-        *          - position in the query string
-        * @param end
-        *          - position in the query string
-        */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">field name</param>
+        /// <param name="text">value</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public QuotedFieldQueryNode(string field, ICharSequence text, int begin,
             int end)
             : base(field, text, begin, end)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/RangeQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/RangeQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/RangeQueryNode.cs
index 697ab3d..4e57d7c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/RangeQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/RangeQueryNode.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    /// This interface should be implemented by a {@link QueryNode} that represents
+    /// This interface should be implemented by an <see cref="IQueryNode"/> that represents
     /// some kind of range query.
     /// </summary>
     /// <typeparam name="T"></typeparam>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/SlopQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/SlopQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/SlopQueryNode.cs
index 2edc767..c232ca4 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/SlopQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/SlopQueryNode.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link SlopQueryNode} represents phrase query with a slop.
+    /// A <see cref="SlopQueryNode"/> represents phrase query with a slop.
     /// 
     /// From Lucene FAQ: Is there a way to use a proximity operator (like near or
     /// within) with Lucene? There is a variable called slop that allows you to
@@ -35,12 +35,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
     {
         private int value = 0;
 
-        /**
-         * @param query
-         *          - QueryNode Tree with the phrase
-         * @param value
-         *          - slop value
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="query">QueryNode Tree with the phrase</param>
+        /// <param name="value">slop value</param>
         public SlopQueryNode(IQueryNode query, int value)
         {
             if (query == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TextableQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TextableQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TextableQueryNode.cs
index aa4b802..152a4a7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TextableQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TextableQueryNode.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// Interface for a node that has text as a {@link CharSequence}
+    /// Interface for a node that has text as a <see cref="ICharSequence"/>
     /// </summary>
     public interface ITextableQueryNode
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TokenizedPhraseQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TokenizedPhraseQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TokenizedPhraseQueryNode.cs
index e5531f7..baa8c18 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TokenizedPhraseQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/TokenizedPhraseQueryNode.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Nodes
      */
 
     /// <summary>
-    /// A {@link TokenizedPhraseQueryNode} represents a node created by a code that
+    /// A <see cref="TokenizedPhraseQueryNode"/> represents a node created by a code that
     /// tokenizes/lemmatizes/analyzes.
     /// </summary>
     public class TokenizedPhraseQueryNode : QueryNodeImpl, IFieldableNode

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ValueQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ValueQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ValueQueryNode.cs
index e1087eb..93662d7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ValueQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Nodes/ValueQueryNode.cs
@@ -18,10 +18,10 @@
      */
 
     /// <summary>
-    /// This interface should be implemented by {@link QueryNode} that holds an
+    /// This interface should be implemented by <see cref="IQueryNode"/> that holds an
     /// arbitrary value.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">the value's type</typeparam>
     public interface IValueQueryNode<T> : IQueryNode
     {
         T Value { get; set; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Parser/EscapeQuerySyntax.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Parser/EscapeQuerySyntax.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Parser/EscapeQuerySyntax.cs
index e29bf50..738253c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Parser/EscapeQuerySyntax.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Parser/EscapeQuerySyntax.cs
@@ -21,8 +21,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Parser
      */
 
     /// <summary>
-    /// A parser needs to implement {@link EscapeQuerySyntax} to allow the QueryNode
-    /// to escape the queries, when the toQueryString method is called.
+    /// A parser needs to implement <see cref="IEscapeQuerySyntax"/> to allow the <see cref="Nodes.IQueryNode"/> 
+    /// to escape the queries, when the ToQueryString method is called.
     /// </summary>
     public interface IEscapeQuerySyntax
     {
@@ -46,6 +46,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Parser
         ICharSequence Escape(ICharSequence text, CultureInfo locale, EscapeQuerySyntax.Type type);
     }
 
+    /// <summary>
+    /// LUCENENET specific static class for mimicking the syntax used for EscapeQuerySyntax.Type
+    /// in Java, since interfaces cannot contain nested enums in .NET anyway.
+    /// </summary>
     public static class EscapeQuerySyntax
     {
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Parser/SyntaxParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Parser/SyntaxParser.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Parser/SyntaxParser.cs
index 0f1f778..9155dfd 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Parser/SyntaxParser.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Parser/SyntaxParser.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Parser
      */
 
     /// <summary>
-    /// A parser needs to implement {@link SyntaxParser} interface
+    /// A parser needs to implement <see cref="ISyntaxParser"/> interface
     /// </summary>
     public interface ISyntaxParser
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Processors/NoChildOptimizationQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/NoChildOptimizationQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/NoChildOptimizationQueryNodeProcessor.cs
index c28728a..881790f 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/NoChildOptimizationQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/NoChildOptimizationQueryNodeProcessor.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
      */
 
     /// <summary>
-    /// A {@link NoChildOptimizationQueryNodeProcessor} removes every
+    /// A <see cref="NoChildOptimizationQueryNodeProcessor"/> removes every
     /// BooleanQueryNode, BoostQueryNode, TokenizedPhraseQueryNode or
     /// ModifierQueryNode that do not have a valid children.
     /// <para>


Mime
View raw message