lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [40/58] lucenenet git commit: QueryParser.Flexible: Documentation comments
Date Tue, 06 Dec 2016 15:12:15 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldBoostMapFCListener.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldBoostMapFCListener.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldBoostMapFCListener.cs
index e0d173e..c701b07 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldBoostMapFCListener.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldBoostMapFCListener.cs
@@ -22,12 +22,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
 
     /// <summary>
     /// This listener listens for every field configuration request and assign a
-    /// {@link ConfigurationKeys#BOOST} to the
-    /// equivalent {@link FieldConfig} based on a defined map: fieldName -> boostValue stored in
-    /// {@link ConfigurationKeys#FIELD_BOOST_MAP}.
+    /// <see cref="ConfigurationKeys.BOOST"/> to the
+    /// equivalent <see cref="FieldConfig"/> based on a defined map: fieldName -> boostValue stored in
+    /// <see cref="ConfigurationKeys.FIELD_BOOST_MAP"/>.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#FIELD_BOOST_MAP"/>
-    /// <seealso cref="ConfigurationKeys#BOOST"/>
+    /// <seealso cref="ConfigurationKeys.FIELD_BOOST_MAP"/>
+    /// <seealso cref="ConfigurationKeys.BOOST"/>
     /// <seealso cref="FieldConfig"/>
     /// <seealso cref="IFieldConfigListener"/>
     public class FieldBoostMapFCListener : IFieldConfigListener

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldDateResolutionFCListener.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldDateResolutionFCListener.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldDateResolutionFCListener.cs
index c276813..121b4f1 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldDateResolutionFCListener.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FieldDateResolutionFCListener.cs
@@ -23,9 +23,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
 
     /// <summary>
     /// This listener listens for every field configuration request and assign a
-    /// {@link ConfigurationKeys#DATE_RESOLUTION} to the equivalent {@link FieldConfig} based
-    /// on a defined map: fieldName -> {@link Resolution} stored in
-    /// {@link ConfigurationKeys#FIELD_DATE_RESOLUTION_MAP}.
+    /// <see cref="ConfigurationKeys.DATE_RESOLUTION"/> to the equivalent <see cref="FieldConfig"/> based
+    /// on a defined map: fieldName -> <see cref="DateTools.Resolution"/> stored in
+    /// <see cref="ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP"/>.
     /// </summary>
     /// <seealso cref="ConfigurationKeys#DATE_RESOLUTION"/>
     /// <seealso cref="ConfigurationKeys#FIELD_DATE_RESOLUTION_MAP"/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FuzzyConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FuzzyConfig.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FuzzyConfig.cs
index 6d38037..4e879fd 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FuzzyConfig.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/FuzzyConfig.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
      */
 
     /// <summary>
-    /// Configuration parameters for {@link FuzzyQuery}s
+    /// Configuration parameters for <see cref="FuzzyQuery"/>s
     /// </summary>
     public class FuzzyConfig
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumberDateFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumberDateFormat.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumberDateFormat.cs
index 55f222e..9d65a3b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumberDateFormat.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumberDateFormat.cs
@@ -31,9 +31,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
     }
 
     /// <summary>
-    /// This {@link Format} parses {@link Long} into date strings and vice-versa. It
-    /// uses the given {@link DateFormat} to parse and format dates, but before, it
-    /// converts {@link Long} to {@link Date} objects or vice-versa.
+    /// This <see cref="NumberFormat"/> parses <see cref="long"/> into date strings and vice-versa. It
+    /// uses the given <paramref name="dateFormat"/> and <see cref="CultureInfo">locale</see> to parse and format dates, but before, it
+    /// converts <see cref="long"/> to <see cref="DateTime"/> objects or vice-versa.
+    /// <para/>
+    /// Note that the <see cref="long"/> value the dates are parsed into and out of represent the number of milliseconds
+    /// since January 1, 1970 0:00:00, also known as the "epoch".
     /// </summary>
     public class NumberDateFormat : NumberFormat
     {
@@ -47,17 +50,22 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
         private readonly DateFormat timeStyle;
         private TimeZoneInfo timeZone = TimeZoneInfo.Local;
 
-        /**
-         * Constructs a {@link NumberDateFormat} object using the given {@link DateFormat}.
-         * 
-         * @param dateFormat {@link DateFormat} used to parse and format dates
-         */
+        /// <summary>
+        /// Constructs a <see cref="NumberDateFormat"/> object using the given <paramref name="dateFormat"/>
+        /// and <paramref name="locale"/>.
+        /// </summary>
+        /// <param name="dateFormat">Date format used to parse and format dates</param>
+        /// <param name="locale"></param>
         public NumberDateFormat(string dateFormat, CultureInfo locale)
             : base(locale)
         {
             this.dateFormat = dateFormat;
         }
 
+        /// <summary>
+        /// Constructs a <see cref="NumberDateFormat"/> object using the given <paramref name="dateStyle"/>,
+        /// <paramref name="timeStyle"/>, and <paramref name="locale"/>.
+        /// </summary>
         public NumberDateFormat(DateFormat dateStyle, DateFormat timeStyle, CultureInfo locale)
             : base(locale)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericConfig.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericConfig.cs
index 4f1fb39..a1f94f4 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericConfig.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericConfig.cs
@@ -23,10 +23,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
 
     /// <summary>
     /// This class holds the configuration used to parse numeric queries and create
-    /// {@link NumericRangeQuery}s.
+    /// <see cref="Search.NumericRangeQuery"/>s.
     /// </summary>
-    /// <seealso cref="NumericRangeQuery"/>
-    /// <seealso cref="NumberFormat"/>
+    /// <seealso cref="Search.NumericRangeQuery"/>
+    /// <seealso cref="Support.NumberFormat"/>
     public class NumericConfig
     {
         private int precisionStep;
@@ -35,21 +35,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
 
         private NumericType type;
 
-        /**
-         * Constructs a {@link NumericConfig} object.
-         * 
-         * @param precisionStep
-         *          the precision used to index the numeric values
-         * @param format
-         *          the {@link NumberFormat} used to parse a {@link String} to
-         *          {@link Number}
-         * @param type
-         *          the numeric type used to index the numeric values
-         * 
-         * @see NumericConfig#setPrecisionStep(int)
-         * @see NumericConfig#setNumberFormat(NumberFormat)
-         * @see #setType(org.apache.lucene.document.FieldType.NumericType)
-         */
+        /// <summary>
+        /// Constructs a <see cref="NumericConfig"/> object.
+        /// </summary>
+        /// <param name="precisionStep">the precision used to index the numeric values</param>
+        /// <param name="format">the <see cref="NumberFormat"/> used to parse a <see cref="string"/> to an <see cref="object"/> representing a .NET numeric type.</param>
+        /// <param name="type">the numeric type used to index the numeric values</param>
+        /// <seealso cref="NumericConfig.PrecisionStep"/>
+        /// <seealso cref="NumericConfig.NumberFormat"/>
+        /// <seealso cref="Type"/>
         public NumericConfig(int precisionStep, NumberFormat format,
             NumericType type)
         {
@@ -58,26 +52,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
             Type = type;
         }
 
-        /**
-         * Gets or sets the precision used to index the numeric values
-         * 
-         * @return the precision used to index the numeric values
-         * 
-         * @see NumericRangeQuery#getPrecisionStep()
-         */
+        /// <summary>
+        /// Gets or sets the precision used to index the numeric values
+        /// </summary>
+        /// <seealso cref="Search.NumericRangeQuery{T}.PrecisionStep"/>
         public virtual int PrecisionStep
         {
             get { return precisionStep; }
             set { precisionStep = value; }
         }
 
-        /**
-         * Gets or Sets the {@link NumberFormat} used to parse a {@link String} to
-         * {@link Number}, cannot be <code>null</code>
-         * 
-         * @return the {@link NumberFormat} used to parse a {@link String} to
-         *         {@link Number}
-         */
+        /// <summary>
+        /// Gets or Sets the <seealso cref="Support.NumberFormat"/> used to parse a <see cref="string"/> to
+        /// <see cref="object"/> representing a .NET numeric type, cannot be <c>null</c>
+        /// </summary>
         public virtual NumberFormat NumberFormat
         {
             get { return format; }
@@ -92,11 +80,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
             }
         }
 
-        /**
-         * Gets or Sets the numeric type used to index the numeric values
-         * 
-         * @return the numeric type used to index the numeric values
-         */
+        /// <summary>
+        /// Gets or Sets the numeric type used to index the numeric values
+        /// </summary>
         public virtual NumericType Type
         {
             get { return type; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericFieldConfigListener.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericFieldConfigListener.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericFieldConfigListener.cs
index 977c1ff..f17ce30 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericFieldConfigListener.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/NumericFieldConfigListener.cs
@@ -22,24 +22,23 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
      */
 
     /// <summary>
-    /// This listener is used to listen to {@link FieldConfig} requests in
-    /// {@link QueryConfigHandler} and add {@link ConfigurationKeys#NUMERIC_CONFIG}
-    /// based on the {@link ConfigurationKeys#NUMERIC_CONFIG_MAP} set in the
-    /// {@link QueryConfigHandler}.
+    /// This listener is used to listen to <see cref="FieldConfig"/> requests in
+    /// <see cref="QueryConfigHandler"/> and add <see cref="ConfigurationKeys.NUMERIC_CONFIG"/>
+    /// based on the <see cref="ConfigurationKeys.NUMERIC_CONFIG_MAP"/> set in the
+    /// <see cref="QueryConfigHandler"/>.
     /// </summary>
     /// <seealso cref="NumericConfig"/>
     /// <seealso cref="QueryConfigHandler"/>
-    /// <seealso cref="ConfigurationKeys#NUMERIC_CONFIG"/>
-    /// <seealso cref="ConfigurationKeys#NUMERIC_CONFIG_MAP"/>
+    /// <seealso cref="ConfigurationKeys.NUMERIC_CONFIG"/>
+    /// <seealso cref="ConfigurationKeys.NUMERIC_CONFIG_MAP"/>
     public class NumericFieldConfigListener : IFieldConfigListener
     {
         private readonly QueryConfigHandler config;
 
-        /**
-         * Construcs a {@link NumericFieldConfigListener} object using the given {@link QueryConfigHandler}.
-         * 
-         * @param config the {@link QueryConfigHandler} it will listen too
-         */
+        /// <summary>
+        /// Constructs a <see cref="NumericFieldConfigListener"/> object using the given <see cref="QueryConfigHandler"/>.
+        /// </summary>
+        /// <param name="config">the <see cref="QueryConfigHandler"/> it will listen too</param>
         public NumericFieldConfigListener(QueryConfigHandler config)
         {
             if (config == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Config/StandardQueryConfigHandler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/StandardQueryConfigHandler.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/StandardQueryConfigHandler.cs
index 5c214cd..f526f36 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Config/StandardQueryConfigHandler.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Config/StandardQueryConfigHandler.cs
@@ -29,11 +29,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
 
     /// <summary>
     /// This query configuration handler is used for almost every processor defined
-    /// in the {@link StandardQueryNodeProcessorPipeline} processor pipeline. It holds
+    /// in the <see cref="Processors.StandardQueryNodeProcessorPipeline"/> processor pipeline. It holds
     /// configuration methods that reproduce the configuration methods that could be set on the old
     /// lucene 2.4 QueryParser class.
     /// </summary>
-    /// <seealso cref="StandardQueryNodeProcessorPipeline"/>
+    /// <seealso cref="Processors.StandardQueryNodeProcessorPipeline"/>
     public class StandardQueryConfigHandler : QueryConfigHandler
     {
         public StandardQueryConfigHandler()
@@ -57,9 +57,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
             Set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP, new HashMap<string, DateTools.Resolution?>());
         }
 
-        /**
-        * Boolean Operator: AND or OR
-        */
+        /// <summary>
+        /// Boolean Operator: AND or OR
+        /// </summary>
         public enum Operator
         {
             AND,
@@ -67,143 +67,112 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Config
         }
     }
 
-    /**
-   * Class holding keys for StandardQueryNodeProcessorPipeline options.
-   */
+    /// <summary>
+    /// Class holding keys for <see cref="Processors.StandardQueryNodeProcessorPipeline"/> options.
+    /// </summary>
     public sealed class ConfigurationKeys
     {
-        /**
-         * Key used to set whether position increments is enabled
-         * 
-         * @see StandardQueryParser#setEnablePositionIncrements(boolean)
-         * @see StandardQueryParser#getEnablePositionIncrements()
-         */
+        /// <summary>
+        /// Key used to set whether position increments is enabled
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.EnablePositionIncrements"/>
         public readonly static ConfigurationKey<bool?> ENABLE_POSITION_INCREMENTS = ConfigurationKey.NewInstance<bool?>();
 
-        /**
-         * Key used to set whether expanded terms should be lower-cased
-         * 
-         * @see StandardQueryParser#setLowercaseExpandedTerms(boolean)
-         * @see StandardQueryParser#getLowercaseExpandedTerms()
-         */
+        /// <summary>
+        /// Key used to set whether expanded terms should be lower-cased
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.LowercaseExpandedTerms"/>
         public readonly static ConfigurationKey<bool?> LOWERCASE_EXPANDED_TERMS = ConfigurationKey.NewInstance<bool?>();
 
-        /**
-         * Key used to set whether leading wildcards are supported
-         * 
-         * @see StandardQueryParser#setAllowLeadingWildcard(boolean)
-         * @see StandardQueryParser#getAllowLeadingWildcard()
-         */
+        /// <summary>
+        /// Key used to set whether leading wildcards are supported
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.AllowLeadingWildcard"/>
         public readonly static ConfigurationKey<bool?> ALLOW_LEADING_WILDCARD = ConfigurationKey.NewInstance<bool?>();
 
-        /**
-         * Key used to set the {@link Analyzer} used for terms found in the query
-         * 
-         * @see StandardQueryParser#setAnalyzer(Analyzer)
-         * @see StandardQueryParser#getAnalyzer()
-         */
+        /// <summary>
+        /// Key used to set the <see cref="Analyzer"/> used for terms found in the query
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.Analyzer"/>
         public readonly static ConfigurationKey<Analyzer> ANALYZER = ConfigurationKey.NewInstance<Analyzer>();
 
-        /**
-         * Key used to set the default boolean operator
-         * 
-         * @see StandardQueryParser#setDefaultOperator(org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator)
-         * @see StandardQueryParser#getDefaultOperator()
-         */
+        /// <summary>
+        /// Key used to set the default boolean operator
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.DefaultOperator"/>
         public readonly static ConfigurationKey<Operator?> DEFAULT_OPERATOR = ConfigurationKey.NewInstance<Operator?>();
 
-        /**
-         * Key used to set the default phrase slop
-         * 
-         * @see StandardQueryParser#setPhraseSlop(int)
-         * @see StandardQueryParser#getPhraseSlop()
-         */
+        /// <summary>
+        /// Key used to set the default phrase slop
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.PhraseSlop"/>
         public readonly static ConfigurationKey<int?> PHRASE_SLOP = ConfigurationKey.NewInstance<int?>();
 
-        /**
-         * Key used to set the {@link Locale} used when parsing the query
-         * 
-         * @see StandardQueryParser#setLocale(Locale)
-         * @see StandardQueryParser#getLocale()
-         */
+        /// <summary>
+        ///  Key used to set the <see cref="CultureInfo">locale</see> used when parsing the query
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.Locale"/>
         public readonly static ConfigurationKey<CultureInfo> LOCALE = ConfigurationKey.NewInstance<CultureInfo>();
 
         public readonly static ConfigurationKey<TimeZoneInfo> TIMEZONE = ConfigurationKey.NewInstance<TimeZoneInfo>();
 
-        /**
-         * Key used to set the {@link RewriteMethod} used when creating queries
-         * 
-         * @see StandardQueryParser#setMultiTermRewriteMethod(org.apache.lucene.search.MultiTermQuery.RewriteMethod)
-         * @see StandardQueryParser#getMultiTermRewriteMethod()
-         */
+        /// <summary>
+        /// Key used to set the <see cref="MultiTermQuery.RewriteMethod"/> used when creating queries
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.MultiTermRewriteMethod"/> 
         public readonly static ConfigurationKey<MultiTermQuery.RewriteMethod> MULTI_TERM_REWRITE_METHOD = ConfigurationKey.NewInstance<MultiTermQuery.RewriteMethod>();
 
-        /**
-         * Key used to set the fields a query should be expanded to when the field
-         * is <code>null</code>
-         * 
-         * @see StandardQueryParser#setMultiFields(CharSequence[])
-         * @see StandardQueryParser#getMultiFields(CharSequence[])
-         */
+        /// <summary>
+        /// Key used to set the fields a query should be expanded to when the field
+        /// is <c>null</c>
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.SetMultiFields(string[])"/>
+        /// <seealso cref="StandardQueryParser.GetMultiFields()"/>
         public readonly static ConfigurationKey<string[]> MULTI_FIELDS = ConfigurationKey.NewInstance<string[]>();
 
-        /**
-         * Key used to set a field to boost map that is used to set the boost for each field
-         * 
-         * @see StandardQueryParser#setFieldsBoost(Map)
-         * @see StandardQueryParser#getFieldsBoost()
-         */
+        /// <summary>
+        /// Key used to set a field to boost map that is used to set the boost for each field
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.FieldsBoost"/>
         public readonly static ConfigurationKey<IDictionary<string, float?>> FIELD_BOOST_MAP = ConfigurationKey.NewInstance<IDictionary<string, float?>>();
 
-        /**
-         * Key used to set a field to {@link Resolution} map that is used
-         * to normalize each date field value.
-         * 
-         * @see StandardQueryParser#setDateResolutionMap(Map)
-         * @see StandardQueryParser#getDateResolutionMap()
-         */
+        /// <summary>
+        /// Key used to set a field to <see cref="DateTools.Resolution"/> map that is used
+        /// to normalize each date field value.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.DateResolutionMap"/>
         public readonly static ConfigurationKey<IDictionary<string, DateTools.Resolution?>> FIELD_DATE_RESOLUTION_MAP = ConfigurationKey.NewInstance<IDictionary<string, DateTools.Resolution?>>();
 
-        /**
-         * Key used to set the {@link FuzzyConfig} used to create fuzzy queries.
-         * 
-         * @see StandardQueryParser#setFuzzyMinSim(float)
-         * @see StandardQueryParser#setFuzzyPrefixLength(int)
-         * @see StandardQueryParser#getFuzzyMinSim()
-         * @see StandardQueryParser#getFuzzyPrefixLength()
-         */
+        /// <summary>
+        /// Key used to set the <see cref="FuzzyConfig"/> used to create fuzzy queries.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.FuzzyMinSim"/>
+        /// <seealso cref="StandardQueryParser.FuzzyPrefixLength"/>
         public readonly static ConfigurationKey<FuzzyConfig> FUZZY_CONFIG = ConfigurationKey.NewInstance<FuzzyConfig>();
 
-        /**
-         * Key used to set default {@link Resolution}.
-         * 
-         * @see StandardQueryParser#setDateResolution(org.apache.lucene.document.DateTools.Resolution)
-         * @see StandardQueryParser#getDateResolution()
-         */
+        /// <summary>
+        /// Key used to set default <see cref="DateTools.Resolution"/>.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.SetDateResolution(DateTools.Resolution)"/>
+        /// <seealso cref="StandardQueryParser.DateResolution"/>
         public readonly static ConfigurationKey<DateTools.Resolution> DATE_RESOLUTION = ConfigurationKey.NewInstance<DateTools.Resolution>();
 
-        /**
-         * Key used to set the boost value in {@link FieldConfig} objects.
-         * 
-         * @see StandardQueryParser#setFieldsBoost(Map)
-         * @see StandardQueryParser#getFieldsBoost()
-         */
+        /// <summary>
+        /// Key used to set the boost value in <see cref="FieldConfig"/> objects.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.FieldsBoost"/>
         public readonly static ConfigurationKey<float?> BOOST = ConfigurationKey.NewInstance<float?>();
 
-        /**
-         * Key used to set a field to its {@link NumericConfig}.
-         * 
-         * @see StandardQueryParser#setNumericConfigMap(Map)
-         * @see StandardQueryParser#getNumericConfigMap()
-         */
+        /// <summary>
+        /// Key used to set a field to its <see cref="NumericConfig"/>.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.NumericConfigMap"/>
         public readonly static ConfigurationKey<NumericConfig> NUMERIC_CONFIG = ConfigurationKey.NewInstance<NumericConfig>();
 
-        /**
-         * Key used to set the {@link NumericConfig} in {@link FieldConfig} for numeric fields.
-         * 
-         * @see StandardQueryParser#setNumericConfigMap(Map)
-         * @see StandardQueryParser#getNumericConfigMap()
-         */
+        /// <summary>
+        /// Key used to set the <see cref="NumericConfig"/> in <see cref="FieldConfig"/> for numeric fields.
+        /// </summary>
+        /// <seealso cref="StandardQueryParser.NumericConfigMap"/>
         public readonly static ConfigurationKey<IDictionary<string, NumericConfig>> NUMERIC_CONFIG_MAP = ConfigurationKey.NewInstance<IDictionary<string, NumericConfig>>();
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/AbstractRangeQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/AbstractRangeQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/AbstractRangeQueryNode.cs
index e3170a4..b27b2ff 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/AbstractRangeQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/AbstractRangeQueryNode.cs
@@ -33,24 +33,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
 
         private bool lowerInclusive, upperInclusive;
 
-        /**
-         * Constructs an {@link AbstractRangeQueryNode}, it should be invoked only by
-         * its extenders.
-         */
+        /// <summary>
+        /// Constructs an <see cref="AbstractRangeQueryNode{T}"/>, it should be invoked only by
+        /// its extenders.
+        /// </summary>
         protected AbstractRangeQueryNode()
         {
             IsLeaf = false;
             Allocate();
         }
 
-        /**
-         * Gets or Sets the field associated with this node.
-         * 
-         * @return the field associated with this node
-         * 
-         * @see FieldableNode
-         */
-
+        /// <summary>
+        /// Gets or Sets the field associated with this node.
+        /// </summary>
+        /// <seealso cref="IFieldableNode"/>
         public virtual string Field
         {
             get
@@ -88,60 +84,55 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
             }
         }
 
-        /**
-         * Returns the lower bound node.
-         * 
-         * @return the lower bound node.
-         */
+        /// <summary>
+        /// Gets the lower bound node.
+        /// </summary>
         public virtual IFieldableNode LowerBound
         {
             get { return (IFieldableNode)GetChildren()[0]; }
         }
 
-        /**
-         * Returns the upper bound node.
-         * 
-         * @return the upper bound node.
-         */
+        /// <summary>
+        /// Gets the upper bound node.
+        /// </summary>
         public virtual IFieldableNode UpperBound
         {
             get { return (IFieldableNode)GetChildren()[1]; }
         }
 
-        /**
-         * Returns whether the lower bound is inclusive or exclusive.
-         * 
-         * @return <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
-         */
-
+        /// <summary>
+        /// Gets whether the lower bound is inclusive or exclusive. 
+        /// </summary>
+        /// <remarks>
+        /// <c>true</c> if the lower bound is inclusive, otherwise, <c>false</c>
+        /// </remarks>
         public virtual bool IsLowerInclusive
         {
             get { return lowerInclusive; }
         }
 
-        /**
-         * Returns whether the upper bound is inclusive or exclusive.
-         * 
-         * @return <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
-         */
+        /// <summary>
+        /// Gets whether the upper bound is inclusive or exclusive.
+        /// </summary>
+        /// <remarks>
+        /// <c>true</c> if the upper bound is inclusive, otherwise, <c>false</c>
+        /// </remarks>
         public virtual bool IsUpperInclusive
         {
             get { return upperInclusive; }
         }
 
-        /**
-         * Sets the lower and upper bounds.
-         * 
-         * @param lower the lower bound, <code>null</code> if lower bound is open
-         * @param upper the upper bound, <code>null</code> if upper bound is open
-         * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
-         * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
-         * 
-         * @see #getLowerBound()
-         * @see #getUpperBound()
-         * @see #isLowerInclusive()
-         * @see #isUpperInclusive()
-         */
+        /// <summary>
+        /// Sets the lower and upper bounds.
+        /// </summary>
+        /// <param name="lower">the lower bound, <c>null</c> if lower bound is open</param>
+        /// <param name="upper">the upper bound, <c>null</c> if upper bound is open</param>
+        /// <param name="lowerInclusive"><c>true</c> if the lower bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="upperInclusive"><c>true</c> if the upper bound is inclusive, otherwise, <c>false</c></param>
+        /// <seealso cref="LowerBound"/>
+        /// <seealso cref="UpperBound"/>
+        /// <seealso cref="IsLowerInclusive"/>
+        /// <seealso cref="IsUpperInclusive"/>
         public virtual void SetBounds(T lower, T upper, bool lowerInclusive,
             bool upperInclusive)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/BooleanModifierNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/BooleanModifierNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/BooleanModifierNode.cs
index b73a42f..c4a51cb 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/BooleanModifierNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/BooleanModifierNode.cs
@@ -20,9 +20,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link BooleanModifierNode} has the same behaviour as
-    /// {@link ModifierQueryNode}, it only indicates that this modifier was added by
-    /// {@link GroupQueryNodeProcessor} and not by the user. 
+    /// A <see cref="BooleanModifierNode"/> has the same behaviour as
+    /// <see cref="ModifierQueryNode"/>, it only indicates that this modifier was added by
+    /// <see cref="Processors.GroupQueryNodeProcessor"/> and not by the user. 
     /// </summary>
     /// <seealso cref="ModifierQueryNode"/>
     public class BooleanModifierNode : ModifierQueryNode

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/MultiPhraseQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/MultiPhraseQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/MultiPhraseQueryNode.cs
index 704760b..9988a38 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/MultiPhraseQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/MultiPhraseQueryNode.cs
@@ -23,8 +23,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link MultiPhraseQueryNode} indicates that its children should be used to
-    /// build a {@link MultiPhraseQuery} instead of {@link PhraseQuery}.
+    /// A <see cref="MultiPhraseQueryNode"/> indicates that its children should be used to
+    /// build a <see cref="Search.MultiPhraseQuery"/> instead of <see cref="Search.PhraseQuery"/>.
     /// </summary>
     public class MultiPhraseQueryNode : QueryNodeImpl, IFieldableNode
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericQueryNode.cs
index 13c5c45..3ee9568 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericQueryNode.cs
@@ -24,8 +24,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
 
     /// <summary>
     /// This query node represents a field query that holds a numeric value. It is
-    /// similar to {@link FieldQueryNode}, however the {@link #getValue()} returns a
-    /// {@link Number}.
+    /// similar to <see cref="FieldQueryNode"/>, however the <see cref="Value"/> returns an
+    /// <see cref="object"/> representing a .NET numeric type.
     /// </summary>
     /// <seealso cref="NumericConfig"/>
     public class NumericQueryNode : QueryNodeImpl, IFieldValuePairQueryNode<object> // LUCENENET TODO: Can we use Decimal??
@@ -36,15 +36,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
 
         private /*Number*/ object value;
 
-        /**
-         * Creates a {@link NumericQueryNode} object using the given field,
-         * {@link Number} value and {@link NumberFormat} used to convert the value to
-         * {@link String}.
-         * 
-         * @param field the field associated with this query node
-         * @param value the value hold by this node
-         * @param numberFormat the {@link NumberFormat} used to convert the value to {@link String}
-         */
+        /// <summary>
+        /// Creates a <see cref="NumericQueryNode"/> object using the given field,
+        /// <see cref="object"/> (representing a .NET numeric type) value and <see cref="Support.NumberFormat"/> used to convert the value to
+        /// <see cref="string"/>.
+        /// </summary>
+        /// <param name="field">the field associated with this query node</param>
+        /// <param name="value">the value hold by this node</param>
+        /// <param name="numberFormat">the <see cref="Support.NumberFormat"/> used to convert the value to <see cref="string"/></param>
         public NumericQueryNode(string field, /*Number*/ object value,
             NumberFormat numberFormat)
             : base()
@@ -55,33 +54,27 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
 
         }
 
-        /**
-         * Gets or Sets the field associated with this node.
-         * 
-         * @return the field associated with this node
-         */
-
+        /// <summary>
+        /// Gets or Sets the field associated with this node.
+        /// </summary>
         public virtual string Field
         {
             get { return this.field; }
             set { this.field = value; }
         }
 
-        /**
-         * This method is used to get the value converted to {@link String} and
-         * escaped using the given {@link EscapeQuerySyntax}.
-         * 
-         * @param escaper the {@link EscapeQuerySyntax} used to escape the value {@link String}
-         * 
-         * @return the value converte to {@link String} and escaped
-         */
+        /// <summary>
+        /// This method is used to get the value converted to <see cref="string"/> and
+        /// escaped using the given <see cref="IEscapeQuerySyntax"/.
+        /// </summary>
+        /// <param name="escaper">The <see cref="IEscapeQuerySyntax"/> used to escape the value <see cref="string"/></param>
+        /// <returns>The value converted to <see cref="string"/> and escaped</returns>
         protected string GetTermEscaped(IEscapeQuerySyntax escaper)
         {
             return escaper.Escape(numberFormat.Format(this.value),
                 CultureInfo.CurrentCulture, EscapeQuerySyntax.Type.NORMAL);
         }
 
-
         public override string ToQueryString(IEscapeQuerySyntax escapeSyntaxParser)
         {
             if (IsDefaultField(this.field))
@@ -94,22 +87,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
             }
         }
 
-        /**
-         * Gets or Sets the {@link NumberFormat} used to convert the value to {@link String}.
-         * 
-         * @return the {@link NumberFormat} used to convert the value to {@link String}
-         */
+        /// <summary>
+        /// Gets or Sets the <see cref="Support.NumberFormat"/> used to convert the value to <see cref="string"/>.
+        /// </summary>
         public virtual NumberFormat NumberFormat
         {
             get { return this.numberFormat; }
             set { this.numberFormat = value; }
         }
 
-        /**
-         * Gets or Sets the numeric value as {@link Number}.
-         * 
-         * @return the numeric value
-         */
+        /// <summary>
+        /// Gets or Sets the numeric value as <see cref="object"/> representing a .NET numeric type.
+        /// </summary>
         public virtual object Value
         {
             get { return value; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
index 4739567..ccdfa2c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
@@ -26,8 +26,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// This query node represents a range query composed by {@link NumericQueryNode}
-    /// bounds, which means the bound values are {@link Number}s.
+    /// This query node represents a range query composed by <see cref="NumericQueryNode"/>
+    /// bounds, which means the bound values are <see cref="object"/>s representing a .NET numeric type.
     /// </summary>
     /// <seealso cref="NumericQueryNode"/>
     /// <seealso cref="AbstractRangeQueryNode{T}"/>
@@ -35,18 +35,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
     {
         public NumericConfig numericConfig;
 
-        /**
-       * Constructs a {@link NumericRangeQueryNode} object using the given
-       * {@link NumericQueryNode} as its bounds and {@link NumericConfig}.
-       * 
-       * @param lower the lower bound
-       * @param upper the upper bound
-       * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
-       * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
-       * @param numericConfig the {@link NumericConfig} that represents associated with the upper and lower bounds
-       * 
-       * @see #setBounds(NumericQueryNode, NumericQueryNode, boolean, boolean, NumericConfig)
-       */
+        /// <summary>
+        /// Constructs a <see cref="NumericRangeQueryNode"/> object using the given
+        /// <see cref="NumericQueryNode"/> as its bounds and <see cref="Config.NumericConfig"/>.
+        /// </summary>
+        /// <param name="lower">the lower bound</param>
+        /// <param name="upper">the upper bound</param>
+        /// <param name="lowerInclusive"><c>true</c> if the lower bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="upperInclusive"><c>true</c> if the upper bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="numericConfig">the <see cref="Config.NumericConfig"/> that represents associated with the upper and lower bounds</param>
+        /// <seealso cref="SetBounds(NumericQueryNode, NumericQueryNode, bool, bool, NumericConfig)"/>
         public NumericRangeQueryNode(NumericQueryNode lower, NumericQueryNode upper,
             bool lowerInclusive, bool upperInclusive, NumericConfig numericConfig)
         {
@@ -80,17 +78,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
             }
         }
 
-        /**
-         * Sets the upper and lower bounds of this range query node and the
-         * {@link NumericConfig} associated with these bounds.
-         * 
-         * @param lower the lower bound
-         * @param upper the upper bound
-         * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
-         * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
-         * @param numericConfig the {@link NumericConfig} that represents associated with the upper and lower bounds
-         * 
-         */
+        /// <summary>
+        /// Sets the upper and lower bounds of this range query node and the
+        /// <see cref="Config.NumericConfig"/> associated with these bounds.
+        /// </summary>
+        /// <param name="lower">the lower bound</param>
+        /// <param name="upper">the upper bound</param>
+        /// <param name="lowerInclusive"><c>true</c> if the lower bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="upperInclusive"><c>true</c> if the upper bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="numericConfig">the <see cref="Config.NumericConfig"/> that represents associated with the upper and lower bounds</param>
         public virtual void SetBounds(NumericQueryNode lower, NumericQueryNode upper,
             bool lowerInclusive, bool upperInclusive, NumericConfig numericConfig)
         {
@@ -140,11 +136,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
             this.numericConfig = numericConfig;
         }
 
-        /**
-         * Returns the {@link NumericConfig} associated with the lower and upper bounds.
-         * 
-         * @return the {@link NumericConfig} associated with the lower and upper bounds
-         */
+        /// <summary>
+        /// Gets the <see cref="Config.NumericConfig"/> associated with the lower and upper bounds.
+        /// </summary>
         public virtual NumericConfig NumericConfig
         {
             get { return this.numericConfig; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/PrefixWildcardQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/PrefixWildcardQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/PrefixWildcardQueryNode.cs
index 4610da9..0348f34 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/PrefixWildcardQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/PrefixWildcardQueryNode.cs
@@ -21,23 +21,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link PrefixWildcardQueryNode} represents wildcardquery that matches abc*
+    /// A <see cref="PrefixWildcardQueryNode"/> represents wildcardquery that matches abc*
     /// or *. This does not apply to phrases, this is a special case on the original
     /// lucene parser. TODO: refactor the code to remove this special case from the
     /// parser. and probably do it on a Processor
     /// </summary>
     public class PrefixWildcardQueryNode : WildcardQueryNode
     {
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value including the wildcard
-        * @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 including the wildcard</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 PrefixWildcardQueryNode(string field, string text,
             int begin, int end)
@@ -45,16 +42,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
         {
         }
 
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value including the wildcard
-        * @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 including the wildcard</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public PrefixWildcardQueryNode(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/Standard/Nodes/RegexpQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/RegexpQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/RegexpQueryNode.cs
index 33de8b7..647cfa8 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/RegexpQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/RegexpQueryNode.cs
@@ -23,40 +23,34 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link RegexpQueryNode} represents {@link RegexpQuery} query Examples: /[a-z]|[0-9]/
+    /// A <see cref="RegexpQueryNode"/> represents <see cref="Search.RegexpQuery"/> query Examples: /[a-z]|[0-9]/
     /// </summary>
     public class RegexpQueryNode : QueryNodeImpl, ITextableQueryNode, IFieldableNode
     {
         private ICharSequence text;
         private string field;
 
-        /**
-         * @param field
-         *          - field name
-         * @param text
-         *          - value that contains a regular expression
-         * @param begin
-         *          - position in the query string
-         * @param end
-         *          - position in the query string
-         */
-         // LUCENENET specific overload for passing text as string
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="field">field name</param>
+        /// <param name="text">value that contains a regular expression</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 RegexpQueryNode(string field, string text, int begin,
             int end)
             : this(field, new StringCharSequenceWrapper(text), begin, end)
         {
         }
 
-        /**
-         * @param field
-         *          - field name
-         * @param text
-         *          - value that contains a regular expression
-         * @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 that contains a regular expression</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public RegexpQueryNode(string field, ICharSequence text, int begin,
             int end)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/StandardBooleanQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/StandardBooleanQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/StandardBooleanQueryNode.cs
index e629a28..4638158 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/StandardBooleanQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/StandardBooleanQueryNode.cs
@@ -21,12 +21,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link StandardBooleanQueryNode} has the same behavior as
-    /// {@link BooleanQueryNode}. It only indicates if the coord should be enabled or
+    /// A <see cref="StandardBooleanQueryNode"/> has the same behavior as
+    /// <see cref="BooleanQueryNode"/>. It only indicates if the coord should be enabled or
     /// not for this boolean query. 
     /// </summary>
-    /// <seealso cref="Similarity#coord(int, int)"/>
-    /// <seealso cref="BooleanQuery"/>
+    /// <seealso cref="Search.Similarities.Similarity.Coord(int, int)"/>
+    /// <seealso cref="Search.BooleanQuery"/>
     public class StandardBooleanQueryNode : BooleanQueryNode
     {
         private bool disableCoord;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/TermRangeQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/TermRangeQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/TermRangeQueryNode.cs
index 064b9f7..0e99d6a 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/TermRangeQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/TermRangeQueryNode.cs
@@ -20,22 +20,21 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// This query node represents a range query composed by {@link FieldQueryNode}
+    /// This query node represents a range query composed by <see cref="FieldQueryNode"/>
     /// bounds, which means the bound values are strings.
     /// </summary>
     /// <seealso cref="FieldQueryNode"/>
     /// <seealso cref="AbstractRangeQueryNode{T}"/>
     public class TermRangeQueryNode : AbstractRangeQueryNode<FieldQueryNode>
     {
-        /**
-   * Constructs a {@link TermRangeQueryNode} object using the given
-   * {@link FieldQueryNode} as its bounds.
-   * 
-   * @param lower the lower bound
-   * @param upper the upper bound
-   * @param lowerInclusive <code>true</code> if the lower bound is inclusive, otherwise, <code>false</code>
-   * @param upperInclusive <code>true</code> if the upper bound is inclusive, otherwise, <code>false</code>
-   */
+        /// <summary>
+        /// Constructs a <see cref="TermRangeQueryNode"/> object using the given
+        /// <see cref="FieldQueryNode"/> as its bounds.
+        /// </summary>
+        /// <param name="lower">the lower bound</param>
+        /// <param name="upper">the upper bound</param>
+        /// <param name="lowerInclusive"><c>true</c> if the lower bound is inclusive, otherwise, <c>false</c></param>
+        /// <param name="upperInclusive"><c>true</c> if the upper bound is inclusive, otherwise, <c>false</c></param>
         public TermRangeQueryNode(FieldQueryNode lower, FieldQueryNode upper,
             bool lowerInclusive, bool upperInclusive)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/WildcardQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/WildcardQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/WildcardQueryNode.cs
index 80352da..1228b02 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/WildcardQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/WildcardQueryNode.cs
@@ -22,21 +22,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
      */
 
     /// <summary>
-    /// A {@link WildcardQueryNode} represents wildcard query This does not apply to
+    /// A <see cref="WildcardQueryNode"/> represents wildcard query This does not apply to
     /// phrases. Examples: a*b*c Fl?w? m?ke*g
     /// </summary>
     public class WildcardQueryNode : FieldQueryNode
     {
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value that contains one or more wild card characters (? or *)
-        * @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 that contains one or more wild card characters (? or *)</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 WildcardQueryNode(string field, string text, int begin,
             int end)
@@ -44,16 +41,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
         {
         }
 
-        /**
-        * @param field
-        *          - field name
-        * @param text
-        *          - value that contains one or more wild card characters (? or *)
-        * @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 that contains one or more wild card characters (? or *)</param>
+        /// <param name="begin">position in the query string</param>
+        /// <param name="end">position in the query string</param>
         public WildcardQueryNode(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/Standard/Parser/CharStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
index ca47c8c..f4c15d6 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/CharStream.cs
@@ -26,104 +26,104 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     /// interface is used in the TokenManager implementation generated by
     /// JavaCCParser.
     /// 
-    /// All the methods except backup can be implemented in any fashion. backup
+    /// All the methods except <see cref="BackUp(int)"/> can be implemented in any fashion. <see cref="BackUp(int)"/>
     /// needs to be implemented correctly for the correct operation of the lexer.
     /// Rest of the methods are all used to get information like line number,
-    /// column number and the String that constitutes a token and are not used
+    /// column number and the string that constitutes a token and are not used
     /// by the lexer. Hence their implementation won't affect the generated lexer's
     /// operation.
     /// </summary>
     public interface ICharStream
     {
-        /**
-        * Returns the next character from the selected input.  The method
-        * of selecting the input is the responsibility of the class
-        * implementing this interface.  Can throw any java.io.IOException.
-        */
+        /// <summary>
+        /// Returns the next character from the selected input.  The method
+        /// of selecting the input is the responsibility of the class
+        /// implementing this interface. Can throw any <see cref="System.IO.IOException"/>.
+        /// </summary>
+        /// <returns>the next character from the selected input.</returns>
         char ReadChar();
 
+        /// <summary>
+        /// Gets the column position of the character last read.
+        /// </summary>
+        /// <seealso cref="EndColumn"/>
         [Obsolete]
-        /**
-         * Returns the column position of the character last read.
-         * @deprecated
-         * @see #getEndColumn
-         */
         int Column { get; }
 
+        /// <summary>
+        /// Gets the line number of the character last read.
+        /// </summary>
+        /// <seealso cref="EndLine"/>
         [Obsolete]
-        /**
-         * Returns the line number of the character last read.
-         * @deprecated
-         * @see #getEndLine
-         */
         int Line { get; }
 
-        /**
-         * Returns the column number of the last character for current token (being
-         * matched after the last call to BeginTOken).
-         */
+        /// <summary>
+        /// Returns the column number of the last character for current token (being
+        /// matched after the last call to BeginTOken).
+        /// </summary>
         int EndColumn { get; }
 
-        /**
-         * Returns the line number of the last character for current token (being
-         * matched after the last call to BeginTOken).
-         */
+        /// <summary>
+        /// Returns the line number of the last character for current token (being
+        /// matched after the last call to BeginTOken).
+        /// </summary>
         int EndLine { get; }
 
-        /**
-         * Returns the column number of the first character for current token (being
-         * matched after the last call to BeginTOken).
-         */
+        /// <summary>
+        /// Returns the column number of the first character for current token (being
+        /// matched after the last call to BeginTOken).
+        /// </summary>
         int BeginColumn { get; }
 
-        /**
-         * Returns the line number of the first character for current token (being
-         * matched after the last call to BeginTOken).
-         */
+        /// <summary>
+        /// Returns the line number of the first character for current token (being
+        /// matched after the last call to BeginTOken).
+        /// </summary>
         int BeginLine { get; }
 
-        /**
-         * Backs up the input stream by amount steps. Lexer calls this method if it
-         * had already read some characters, but could not use them to match a
-         * (longer) token. So, they will be used again as the prefix of the next
-         * token and it is the implemetation's responsibility to do this right.
-         */
+        /// <summary>
+        /// Backs up the input stream by amount steps. Lexer calls this method if it
+        /// had already read some characters, but could not use them to match a
+        /// (longer) token. So, they will be used again as the prefix of the next
+        /// token and it is the implemetation's responsibility to do this right.
+        /// </summary>
         void BackUp(int amount);
 
-        /**
-         * Returns the next character that marks the beginning of the next token.
-         * All characters must remain in the buffer between two successive calls
-         * to this method to implement backup correctly.
-         */
+        /// <summary>
+        /// Returns the next character that marks the beginning of the next token.
+        /// All characters must remain in the buffer between two successive calls
+        /// to this method to implement backup correctly.
+        /// </summary>
         char BeginToken();
 
-        /**
-         * Returns a string made up of characters from the marked token beginning
-         * to the current buffer position. Implementations have the choice of returning
-         * anything that they want to. For example, for efficiency, one might decide
-         * to just return null, which is a valid implementation.
-         */
+        /// <summary>
+        /// Returns a string made up of characters from the marked token beginning
+        /// to the current buffer position. Implementations have the choice of returning
+        /// anything that they want to. For example, for efficiency, one might decide
+        /// to just return null, which is a valid implementation.
+        /// </summary>
         string GetImage();
 
-        /**
-         * Returns an array of characters that make up the suffix of length 'len' for
-         * the currently matched token. This is used to build up the matched string
-         * for use in actions in the case of MORE. A simple and inefficient
-         * implementation of this is as follows :
-         *
-         *   {
-         *      String t = GetImage();
-         *      return t.substring(t.length() - len, t.length()).toCharArray();
-         *   }
-         */
+        /// <summary>
+        /// Returns an array of characters that make up the suffix of length 'len' for
+        /// the currently matched token. This is used to build up the matched string
+        /// for use in actions in the case of MORE. A simple and inefficient
+        /// implementation of this is as follows :
+        /// <code>
+        /// {
+        ///     string t = GetImage();
+        ///     return t.Substring(t.Length - len, t.Length - (t.Length - len)).ToCharArray();
+        /// }
+        /// </code>
+        /// </summary>
         char[] GetSuffix(int len);
 
-        /**
-         * The lexer calls this function to indicate that it is done with the stream
-         * and hence implementations can free any resources held by this class.
-         * Again, the body of this function can be just empty and it will not
-         * affect the lexer's operation.
-         */
+        /// <summary>
+        /// The lexer calls this function to indicate that it is done with the stream
+        /// and hence implementations can free any resources held by this class.
+        /// Again, the body of this function can be just empty and it will not
+        /// affect the lexer's operation.
+        /// </summary>
         void Done();
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/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 8f5d074..6785ae0 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
      */
 
     /// <summary>
-    /// Implementation of {@link EscapeQuerySyntax} for the standard lucene
+    /// Implementation of <see cref="IEscapeQuerySyntax"/> for the standard lucene
     /// syntax.
     /// </summary>
     public class EscapeQuerySyntaxImpl : IEscapeQuerySyntax
@@ -107,17 +107,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return term;
         }
 
-        /**
-         * replace with ignore case
-         * 
-         * @param string
-         *          string to get replaced
-         * @param sequence1
-         *          the old character sequence in lowercase
-         * @param escapeChar
-         *          the new character to prefix sequence1 in return string.
-         * @return the new String
-         */
+        /// <summary>
+        /// replace with ignore case
+        /// </summary>
+        /// <param name="string">string to get replaced</param>
+        /// <param name="sequence1">the old character sequence in lowercase</param>
+        /// <param name="escapeChar">the new character to prefix sequence1 in return string.</param>
+        /// <param name="locale"></param>
+        /// <returns>the new <see cref="ICharSequence"/></returns>
         private static ICharSequence ReplaceIgnoreCase(ICharSequence @string,
             string sequence1, string escapeChar, CultureInfo locale)
         {
@@ -183,15 +180,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return result.ToString().ToCharSequence();
         }
 
-        /**
-         * 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
-         */
+        /// <summary>
+        /// escape all tokens that are part of the parser syntax on a given string
+        /// </summary>
+        /// <param name="str">string to get replaced</param>
+        /// <param name="locale">locale to be used when performing string compares</param>
+        /// <returns>the new <see cref="ICharSequence"/></returns>
         private static ICharSequence EscapeWhiteChar(ICharSequence str,
             CultureInfo locale)
         {
@@ -245,14 +239,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             }
         }
 
-        /**
-         * Returns a String where the escape char has been removed, or kept only once
-         * if there was a double escape.
-         * 
-         * Supports escaped unicode characters, e. g. translates <code>A</code> to
-         * <code>A</code>.
-         * 
-         */
+        /// <summary>
+        /// Returns a string where the escape char has been removed, or kept only once
+        /// if there was a double escape.
+        /// <para/>
+        /// Supports escaped unicode characters, e. g. translates <c>A</c> to
+        /// <c>A</c>.
+        /// </summary>
         public static UnescapedCharSequence DiscardEscapeChar(string input)
         {
             // Create char array to hold unescaped char sequence
@@ -334,7 +327,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return new UnescapedCharSequence(output, wasEscaped, 0, length);
         }
 
-        /** Returns the numeric value of the hexadecimal character */
+        /// <summary>
+        /// Returns the numeric value of the hexadecimal character
+        /// </summary>
         private static int HexToInt(char c)
         {
             if ('0' <= c && c <= '9')

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/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 8307a29..8538374 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/FastCharStream.cs
@@ -22,8 +22,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     /// <summary>
     /// An efficient implementation of JavaCC's CharStream interface.  <p>Note that
     /// this does not do line-number counting, but instead keeps track of the
-    /// character position of the token in the input, as required by Lucene's {@link
-    /// org.apache.lucene.analysis.Token} API. 
+    /// character position of the token in the input, as required by Lucene's
+    /// <see cref="Token"/> API. 
     /// </summary>
     public sealed class FastCharStream : ICharStream
     {
@@ -37,7 +37,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
 
         TextReader input;            // source of chars
 
-        /** Constructs from a Reader. */
+        /// <summary>
+        /// Constructs from a <see cref="TextReader"/>.
+        /// </summary>
         public FastCharStream(TextReader r)
         {
             input = r;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
index 8959255..f1b4ea9 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/ParseException.cs
@@ -35,12 +35,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     [Serializable]
     public class ParseException : QueryNodeParseException
     {
-        /**
-         * This constructor is used by the method "generateParseException"
-         * in the generated parser.  Calling this constructor generates
-         * a new object of this type with the fields "currentToken",
-         * "expectedTokenSequences", and "tokenImage" set.
-         */
+        /// <summary>
+        /// This constructor is used by the method "generateParseException"
+        /// in the generated parser.  Calling this constructor generates
+        /// a new object of this type with the fields "currentToken",
+        /// "expectedTokenSequences", and "tokenImage" set.
+        /// </summary>
         public ParseException(Token currentTokenVal,
             int[][] expectedTokenSequencesVal, string[] tokenImageVal)
             : base(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, Initialize(
@@ -51,54 +51,60 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             this.tokenImage = tokenImageVal;
         }
 
-        /**
-         * The following constructors are for use by you for whatever
-         * purpose you can think of.  Constructing the exception in this
-         * manner makes the exception behave in the normal way - i.e., as
-         * documented in the class "Throwable".  The fields "errorToken",
-         * "expectedTokenSequences", and "tokenImage" do not contain
-         * relevant information.  The JavaCC generated code does not use
-         * these constructors.
-         */
+        /// <summary>
+        /// The following constructors are for use by you for whatever
+        /// purpose you can think of.  Constructing the exception in this
+        /// manner makes the exception behave in the normal way - i.e., as
+        /// documented in the class "Throwable".  The fields "errorToken",
+        /// "expectedTokenSequences", and "tokenImage" do not contain
+        /// relevant information.  The JavaCC generated code does not use
+        /// these constructors.
+        /// </summary>
         public ParseException()
             : base(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, "Error"))
         {
         }
 
-        /** Constructor with message. */
+        /// <summary>
+        /// Constructor with message.
+        /// </summary>
         public ParseException(IMessage message)
             : base(message)
         {
         }
 
-        /**
-         * This is the last token that has been consumed successfully.  If
-         * this object has been created due to a parse error, the token
-         * followng this token will (therefore) be the first error token.
-         */
+        /// <summary>
+        /// This is the last token that has been consumed successfully.  If
+        /// this object has been created due to a parse error, the token
+        /// followng this token will (therefore) be the first error token.
+        /// </summary>
         public Token currentToken;
 
-        /**
-         * Each entry in this array is an array of integers.  Each array
-         * of integers represents a sequence of tokens (by their ordinal
-         * values) that is expected at this point of the parse.
-         */
+        /// <summary>
+        /// Each entry in this array is an array of integers.  Each array
+        /// of integers represents a sequence of tokens (by their ordinal
+        /// values) that is expected at this point of the parse.
+        /// </summary>
         public int[][] expectedTokenSequences;
 
-        /**
-         * This is a reference to the "tokenImage" array of the generated
-         * parser within which the parse error occurred.  This array is
-         * defined in the generated ...Constants interface.
-         */
+        /// <summary>
+        /// This is a reference to the "tokenImage" array of the generated
+        /// parser within which the parse error occurred.  This array is
+        /// defined in the generated ...Constants interface.
+        /// </summary>
         public string[] tokenImage;
 
-        /**
-         * It uses "currentToken" and "expectedTokenSequences" to generate a parse
-         * error message and returns it.  If this object has been created
-         * due to a parse error, and you do not catch it (it gets thrown
-         * from the parser) the correct error message
-         * gets displayed.
-         */
+        /// <summary>
+        /// It uses <paramref name="currentToken"/> and <paramref name="expectedTokenSequences"/> to generate a parse
+        /// error message and returns it.  If this object has been created
+        /// due to a parse error, and you do not catch it (it gets thrown
+        /// from the parser) the correct error message
+        /// gets displayed.
+        /// </summary>
+        /// <param name="currentToken"></param>
+        /// <param name="expectedTokenSequences"></param>
+        /// <param name="tokenImage"></param>
+        /// <returns></returns>
         private static string Initialize(Token currentToken,
                                  int[][] expectedTokenSequences,
                                  string[] tokenImage)
@@ -153,16 +159,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return retval;
         }
 
-        /**
-         * The end of line string for this machine.
-         */
+        /// <summary>
+        /// The end of line string for this machine.
+        /// </summary>
         protected string eol = Environment.NewLine;
 
-        /**
-         * Used to convert raw characters to their escaped version
-         * when these raw version cannot be used as part of an ASCII
-         * string literal.
-         */
+        /// <summary>
+        /// Used to convert raw characters to their escaped version
+        /// when these raw version cannot be used as part of an ASCII
+        /// string literal.
+        /// </summary>
         static string Add_Escapes(string str)
         {
             StringBuilder retval = new StringBuilder();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParser.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParser.cs
index afb3801..9f75881 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParser.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParser.cs
@@ -44,10 +44,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         {
         }
 
-        /** Parses a query string, returning a {@link org.apache.lucene.queryparser.flexible.core.nodes.QueryNode}.
-        *  @param query  the query string to be parsed.
-        *  @throws ParseException if the parsing fails
-        */
+        /// <summary>
+        /// Parses a query string, returning a <see cref="IQueryNode"/>.
+        /// </summary>
+        /// <param name="query">the query string to be parsed.</param>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        /// <exception cref="ParseException">if the parsing fails</exception>
         public IQueryNode Parse(string query, string field)
         {
             ReInit(new FastCharStream(new StringReader(query)));
@@ -952,11 +955,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return false;
         }
 
-        /** Generated Token Manager. */
+        /// <summary>Generated Token Manager.</summary>
         public StandardSyntaxParserTokenManager token_source;
-        /** Current token. */
+        /// <summary>Current token.</summary>
         public Token token;
-        /** Next token. */
+        /// <summary>Next token.</summary>
         public Token jj_nt;
         private int jj_ntk;
         private Token jj_scanpos, jj_lastpos;
@@ -982,7 +985,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         private bool jj_rescan = false;
         private int jj_gc = 0;
 
-        /** Constructor with user supplied CharStream. */
+        /// <summary>
+        /// Constructor with user supplied <see cref="ICharStream"/>.
+        /// </summary>
         public StandardSyntaxParser(ICharStream stream)
         {
             token_source = new StandardSyntaxParserTokenManager(stream);
@@ -993,7 +998,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
         }
 
-        /** Reinitialise. */
+        /// <summary>Reinitialize.</summary>
         public void ReInit(ICharStream stream)
         {
             token_source.ReInit(stream);
@@ -1004,7 +1009,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
         }
 
-        /** Constructor with generated Token Manager. */
+        /// <summary>Constructor with generated Token Manager.</summary>
         public StandardSyntaxParser(StandardSyntaxParserTokenManager tm)
         {
             token_source = tm;
@@ -1015,7 +1020,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             for (int i = 0; i < jj_2_rtns.Length; i++) jj_2_rtns[i] = new JJCalls();
         }
 
-        /** Reinitialise. */
+        /// <summary>Reinitialize.</summary>
         public void ReInit(StandardSyntaxParserTokenManager tm)
         {
             token_source = tm;
@@ -1087,7 +1092,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         }
 
 
-        /** Get the next Token. */
+        /// <summary>Get the next Token.</summary>
         public Token getNextToken()
         {
             if (token.next != null) token = token.next;
@@ -1097,7 +1102,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return token;
         }
 
-        /** Get the specific Token. */
+        /// <summary>Get the specific Token.</summary>
         public Token getToken(int index)
         {
             Token t = token;
@@ -1159,7 +1164,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             }
         }
 
-        /** Generate ParseException. */
+        /// <summary>Generate ParseException.</summary>
         public virtual ParseException generateParseException()
         {
             jj_expentries.Clear();
@@ -1206,12 +1211,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return new ParseException(token, exptokseq, StandardSyntaxParserConstants.TokenImage);
         }
 
-        /** Enable tracing. */
+        /// <summary>Enable tracing.</summary>
         public void enable_tracing()
         {
         }
 
-        /** Disable tracing. */
+        /// <summary>Disable tracing.</summary>
         public void disable_tracing()
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserConstants.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserConstants.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserConstants.cs
index 9642186..f1aaef7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserConstants.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserConstants.cs
@@ -97,6 +97,9 @@
         public const int DEFAULT = 2;
     }
 
+    /// <summary>
+    /// Token literal values and constants.
+    /// </summary>
     public static class StandardSyntaxParserConstants
     {
         /// <summary>Literal token values.</summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/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 0774c21..8095ef6 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/StandardSyntaxParserTokenManager.cs
@@ -25,9 +25,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     /// </summary>
     public class StandardSyntaxParserTokenManager /*: StandardSyntaxParserConstants*/
     {
-        /** Debug output. */
+        /// <summary>Debug output.</summary>
         public TextWriter debugStream = Console.Out;
-        /** Set debug output. */
+        /// <summary>Set debug output.</summary>
         public void setDebugStream(TextWriter ds) { debugStream = ds; }
         private int jjStopStringLiteralDfa_2(int pos, long active0)
         {
@@ -751,21 +751,21 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             }
         }
 
-        /** Token literal values. */
+        /// <summary>Token literal values.</summary>
         public static readonly string[] jjstrLiteralImages = {
             "", null, null, null, null, null, null, null, null, null, null, "\x002B", "\x002D",
             "\x0028", "\x0029", "\x003A", "\x003D", "\x003C", "\x003C\x003D", "\x003E", "\x003E\x003D", "\x005E", null, null,
             null, null, "\x005B", "\x007B", null, "\x0054\x004F", "\x005D", "\x007D", null, null,
         };
 
-        /** Lexer state names. */
+        /// <summary>Lexer state names.</summary>
         public static readonly string[] lexStateNames = {
            "Boost",
            "Range",
            "DEFAULT",
         };
 
-        /** Lex State array. */
+        /// <summary>Lex State array.</summary>
         public static readonly int[] jjnewLexState = {
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1,
            -1, 1, 1, 2, -1, 2, 2, -1, -1,
@@ -780,20 +780,20 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         private readonly uint[] jjrounds = new uint[33];
         private readonly int[] jjstateSet = new int[66];
         protected char curChar;
-        /** Constructor. */
+        /// <summary>Constructor.</summary>
         public StandardSyntaxParserTokenManager(ICharStream stream)
         {
             input_stream = stream;
         }
 
-        /** Constructor. */
+        /// <summary>Constructor.</summary>
         public StandardSyntaxParserTokenManager(ICharStream stream, int lexState)
             : this(stream)
         {
             SwitchTo(lexState);
         }
 
-        /** Reinitialise parser. */
+        /// <summary>Reinitialize parser.</summary>
         public void ReInit(ICharStream stream)
         {
             jjmatchedPos = jjnewStateCnt = 0;
@@ -809,14 +809,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                 jjrounds[i] = 0x80000000;
         }
 
-        /** Reinitialise parser. */
+        /// <summary>Reinitialize parser.</summary>
         public void ReInit(ICharStream stream, int lexState)
         {
             ReInit(stream);
             SwitchTo(lexState);
         }
 
-        /** Switch to specified lex state. */
+        /// <summary>Switch to specified lex state.</summary>
         public void SwitchTo(int lexState)
         {
             if (lexState >= 3 || lexState < 0)
@@ -856,7 +856,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
         internal int jjmatchedPos;
         internal int jjmatchedKind;
 
-        /** Get the next Token. */
+        /// <summary>Get the next Token.</summary>
         public Token getNextToken()
         {
             Token matchedToken;


Mime
View raw message