lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [41/58] lucenenet git commit: QueryParser.Flexible: Documentation comments
Date Tue, 06 Dec 2016 15:12:16 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessor.cs
index 2ed96f6..94d14f5 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessor.cs
@@ -21,52 +21,49 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
      */
 
     /// <summary>
-    /// A {@link QueryNodeProcessor} is an interface for classes that process a
-    /// {@link QueryNode} tree.
+    /// An <see cref="IQueryNodeProcessor"/> is an interface for classes that process a
+    /// <see cref="IQueryNode"/> tree.
     /// <para>
     /// The implementor of this class should perform some operation on a query node
     /// tree and return the same or another query node tree.
     /// </para>
     /// <para>
-    /// It also may carry a {@link QueryConfigHandler} object that contains
+    /// It also may carry a <see cref="QueryConfigHandler"/> object that contains
     /// configuration about the query represented by the query tree or the
     /// collection/index where it's intended to be executed.
     /// </para>
     /// <para>
-    /// In case there is any {@link QueryConfigHandler} associated to the query tree
+    /// In case there is any <see cref="QueryConfigHandler"/> associated to the query tree
     /// to be processed, it should be set using
-    /// {@link QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)} before
-    /// {@link QueryNodeProcessor#process(QueryNode)} is invoked.
+    /// <see cref="SetQueryConfigHandler(QueryConfigHandler)"/> before
+    /// <see cref="Process(IQueryNode)"/> is invoked.
     /// </para>
     /// </summary>
     /// <seealso cref="IQueryNode"/>
-    /// <seealso cref="QueryNodeProcessor"/>
+    /// <seealso cref="IQueryNodeProcessor"/>
     /// <seealso cref="QueryConfigHandler"/>
     public interface IQueryNodeProcessor
     {
-        /**
-        * Processes a query node tree. It may return the same or another query tree.
-        * I should never return <code>null</code>.
-        * 
-        * @param queryTree
-        *          tree root node
-        * 
-        * @return the processed query tree
-        */
+        /// <summary>
+        /// Processes a query node tree. It may return the same or another query tree.
+        /// I should never return <c>null</c>.
+        /// </summary>
+        /// <param name="queryTree">tree root node</param>
+        /// <returns>the processed query tree</returns>
         IQueryNode Process(IQueryNode queryTree);
 
-        /**
-         * Sets the {@link QueryConfigHandler} associated to the query tree.
-         */
+        /// <summary>
+        /// Sets the <see cref="QueryConfigHandler"/> associated to the query tree.
+        /// </summary>
+        /// <param name="queryConfigHandler"></param>
         void SetQueryConfigHandler(QueryConfigHandler queryConfigHandler);
 
-        /**
-         * Returns the {@link QueryConfigHandler} associated to the query tree if any,
-         * otherwise it returns <code>null</code>
-         * 
-         * @return the {@link QueryConfigHandler} associated to the query tree if any,
-         *         otherwise it returns <code>null</code>
-         */
+        /// <summary>
+        /// Returns the <see cref="QueryConfigHandler"/> associated to the query tree if any,
+        /// otherwise it returns <c>null</c>
+        /// </summary>
+        /// <returns>the <see cref="QueryConfigHandler"/> associated to the query tree if any,
+        /// otherwise it returns <c>null</c></returns>
         QueryConfigHandler GetQueryConfigHandler();
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorImpl.cs
index b41a07e..d2965a0 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorImpl.cs
@@ -22,6 +22,49 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
      * limitations under the License.
      */
 
+    /// <summary>
+    /// This is a default implementation for the <see cref="IQueryNodeProcessor"/>
+    /// interface, it's an abstract class, so it should be extended by classes that
+    /// want to process a <see cref="IQueryNode"/> tree.
+    /// <para>
+    /// This class process <see cref="IQueryNode"/>s from left to right in the tree. While
+    /// it's walking down the tree, for every node,
+    /// <see cref="PreProcessNode(IQueryNode)"/> is invoked. After a node's children are
+    /// processed, <see cref="PostProcessNode(IQueryNode)"/> is invoked for that node.
+    /// <see cref="SetChildrenOrder(IList{IQueryNode})"/> is invoked before
+    /// <see cref="PostProcessNode(IQueryNode)"/> only if the node has at least one child,
+    /// in <see cref="SetChildrenOrder(IList{IQueryNode})"/> the implementor might redefine the
+    /// children order or remove any children from the children list.
+    /// </para>
+    /// <para>
+    /// Here is an example about how it process the nodes:
+    /// </para>
+    /// <pre>
+    ///      a
+    ///     / \
+    ///    b   e
+    ///   / \
+    ///  c   d
+    /// </pre>
+    /// <para>
+    /// Here is the order the methods would be invoked for the tree described above:
+    /// </para>
+    /// <code>
+    ///     PreProcessNode( a );
+    ///     PreProcessNode( b );
+    ///     PreProcessNode( c );
+    ///     PostProcessNode( c );
+    ///     PreProcessNode( d );
+    ///     PostProcessNode( d );
+    ///     SetChildrenOrder( bChildrenList );
+    ///     PostProcessNode( b );
+    ///     PreProcessNode( e );
+    ///     PostProcessNode( e );
+    ///     SetChildrenOrder( aChildrenList );
+    ///     PostProcessNode( a )
+    /// </code>
+    /// </summary>
+    /// <seealso cref="IQueryNodeProcessor"/>
     public abstract class QueryNodeProcessorImpl : IQueryNodeProcessor
     {
         private List<ChildrenList> childrenListPool = new List<ChildrenList>();
@@ -54,14 +97,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             return queryTree;
         }
 
-        /**
-         * This method is called every time a child is processed.
-         * 
-         * @param queryTree
-         *          the query node child to be processed
-         * @throws QueryNodeException
-         *           if something goes wrong during the query node processing
-         */
+        /// <summary>
+        /// This method is called every time a child is processed.
+        /// </summary>
+        /// <param name="queryTree">the query node child to be processed</param>
+        /// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
         protected virtual void ProcessChildren(IQueryNode queryTree)
         {
             IList<IQueryNode> children = queryTree.GetChildren();
@@ -123,74 +163,53 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             return list;
         }
 
-        /**
-         * For reference about this method check:
-         * {@link QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)}.
-         * 
-         * @param queryConfigHandler
-         *          the query configuration handler to be set.
-         * 
-         * @see QueryNodeProcessor#getQueryConfigHandler()
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// For reference about this method check:
+        /// <see cref="IQueryNodeProcessor.SetQueryConfigHandler(QueryConfigHandler)"/>.
+        /// </summary>
+        /// <param name="queryConfigHandler">the query configuration handler to be set.</param>
+        /// <seealso cref="IQueryNodeProcessor.SetQueryConfigHandler(QueryConfigHandler)"/>
+        /// <seealso cref="QueryConfigHandler"/>
         public virtual void SetQueryConfigHandler(QueryConfigHandler queryConfigHandler)
         {
             this.queryConfig = queryConfigHandler;
         }
 
-        /**
-         * For reference about this method check:
-         * {@link QueryNodeProcessor#getQueryConfigHandler()}.
-         * 
-         * @return QueryConfigHandler the query configuration handler to be set.
-         * 
-         * @see QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// For reference about this method check:
+        /// <see cref="IQueryNodeProcessor.GetQueryConfigHandler()"/>.
+        /// </summary>
+        /// <returns><see cref="QueryConfigHandler"/> the query configuration handler to be set.</returns>
+        /// <seealso cref="IQueryNodeProcessor.SetQueryConfigHandler(QueryConfigHandler)"/>
+        /// <seealso cref="QueryConfigHandler"/>
         public virtual QueryConfigHandler GetQueryConfigHandler()
         {
             return this.queryConfig;
         }
 
-        /**
-         * This method is invoked for every node when walking down the tree.
-         * 
-         * @param node
-         *          the query node to be pre-processed
-         * 
-         * @return a query node
-         * 
-         * @throws QueryNodeException
-         *           if something goes wrong during the query node processing
-         */
+        /// <summary>
+        /// This method is invoked for every node when walking down the tree.
+        /// </summary>
+        /// <param name="node">the query node to be pre-processed</param>
+        /// <returns>a query node</returns>
+        /// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
         protected abstract IQueryNode PreProcessNode(IQueryNode node);
 
-        /**
-         * This method is invoked for every node when walking up the tree.
-         * 
-         * @param node
-         *          node the query node to be post-processed
-         * 
-         * @return a query node
-         * 
-         * @throws QueryNodeException
-         *           if something goes wrong during the query node processing
-         */
+        /// <summary>
+        /// This method is invoked for every node when walking up the tree.
+        /// </summary>
+        /// <param name="node">node the query node to be post-processed</param>
+        /// <returns>a query node</returns>
+        /// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
         protected abstract IQueryNode PostProcessNode(IQueryNode node);
 
-        /**
-         * This method is invoked for every node that has at least on child. It's
-         * invoked right before {@link #postProcessNode(QueryNode)} is invoked.
-         * 
-         * @param children
-         *          the list containing all current node's children
-         * 
-         * @return a new list containing all children that should be set to the
-         *         current node
-         * 
-         * @throws QueryNodeException
-         *           if something goes wrong during the query node processing
-         */
+        /// <summary>
+        /// This method is invoked for every node that has at least on child. It's
+        /// invoked right before <see cref="PostProcessNode(IQueryNode)"/> is invoked.
+        /// </summary>
+        /// <param name="children">the list containing all current node's children</param>
+        /// <returns>a new list containing all children that should be set to the current node</returns>
+        /// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
         protected abstract IList<IQueryNode> SetChildrenOrder(IList<IQueryNode> children);
 
         private class ChildrenList : List<IQueryNode>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorPipeline.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorPipeline.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorPipeline.cs
index 3c6f548..d894c4f 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorPipeline.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/QueryNodeProcessorPipeline.cs
@@ -23,54 +23,60 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
      * limitations under the License.
      */
 
+    /// <summary>
+    /// A <see cref="QueryNodeProcessorPipeline"/> class should be used to build a query
+    /// node processor pipeline.
+    /// <para/>
+    /// When a query node tree is processed using this class, it passes the query
+    /// node tree to each processor on the pipeline and the result from each
+    /// processor is passed to the next one, always following the order the
+    /// processors were on the pipeline.
+    /// <para/>
+    /// When a <see cref="QueryConfigHandler"/> object is set on a
+    /// <see cref="QueryNodeProcessorPipeline"/>, it also takes care of setting this
+    /// <see cref="QueryConfigHandler"/> on all processor on pipeline.
+    /// </summary>
     public class QueryNodeProcessorPipeline : IQueryNodeProcessor, IList<IQueryNodeProcessor>
     {
         private List<IQueryNodeProcessor> processors = new List<IQueryNodeProcessor>();
 
         private QueryConfigHandler queryConfig;
 
-        /**
-         * Constructs an empty query node processor pipeline.
-         */
+        /// <summary>
+        /// Constructs an empty query node processor pipeline.
+        /// </summary>
         public QueryNodeProcessorPipeline()
         {
             // empty constructor
         }
 
-        /**
-         * Constructs with a {@link QueryConfigHandler} object.
-         */
+        /// <summary>
+        /// Constructs with a <see cref="QueryConfigHandler"/> object.
+        /// </summary>
         public QueryNodeProcessorPipeline(QueryConfigHandler queryConfigHandler)
         {
             this.queryConfig = queryConfigHandler;
         }
 
-        /**
-         * For reference about this method check:
-         * {@link QueryNodeProcessor#getQueryConfigHandler()}.
-         * 
-         * @return QueryConfigHandler the query configuration handler to be set.
-         * 
-         * @see QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// For reference about this method check:
+        /// <see cref="IQueryNodeProcessor.GetQueryConfigHandler()"/>.
+        /// </summary>
+        /// <returns><see cref="QueryConfigHandler"/> the query configuration handler to be set.</returns>
+        /// <seealso cref="IQueryNodeProcessor.SetQueryConfigHandler(QueryConfigHandler)"/>
+        /// <seealso cref="QueryConfigHandler"/>
         public virtual QueryConfigHandler GetQueryConfigHandler()
         {
             return this.queryConfig;
         }
 
-        /**
-         * For reference about this method check:
-         * {@link QueryNodeProcessor#process(QueryNode)}.
-         * 
-         * @param queryTree the query node tree to be processed
-         * 
-         * @throws QueryNodeException if something goes wrong during the query node
-         *         processing
-         * 
-         * @see QueryNode
-         */
-
+        /// <summary>
+        /// For reference about this method check:
+        /// <see cref="IQueryNodeProcessor.Process(IQueryNode)"/>.
+        /// </summary>
+        /// <param name="queryTree">the query node tree to be processed</param>
+        /// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
+        /// <seealso cref="IQueryNode"/>
         public virtual IQueryNode Process(IQueryNode queryTree)
         {
             foreach (IQueryNodeProcessor processor in this.processors)
@@ -81,15 +87,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             return queryTree;
         }
 
-        /**
-         * For reference about this method check:
-         * {@link QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)}.
-         * 
-         * @param queryConfigHandler the query configuration handler to be set.
-         * 
-         * @see QueryNodeProcessor#getQueryConfigHandler()
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// For reference about this method check:
+        /// <see cref="IQueryNodeProcessor.SetQueryConfigHandler(QueryConfigHandler)"/>.
+        /// </summary>
+        /// <param name="queryConfigHandler">the query configuration handler to be set.</param>
+        /// <seealso cref="IQueryNodeProcessor.GetQueryConfigHandler()"/>
+        /// <seealso cref="QueryConfigHandler"/>
         public virtual void SetQueryConfigHandler(QueryConfigHandler queryConfigHandler)
         {
             this.queryConfig = queryConfigHandler;
@@ -100,9 +104,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             }
         }
 
-        /**
-         * @see List#add(Object)
-         */
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Add(IQueryNodeProcessor)"/> 
+        /// </summary>
         public virtual bool Add(IQueryNodeProcessor processor)
         {
             this.processors.Add(processor);
@@ -116,22 +120,22 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             return added;
         }
 
-        /**
-         * @see List#clear()
-         */
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Clear()"/> 
+        /// </summary>
         public virtual void Clear()
         {
             this.processors.Clear();
         }
 
-        /**
-         * @see List#contains(Object)
-         */
         public virtual bool Contains(object o)
         {
             return this.processors.Contains(o);
         }
 
+        /// <summary>
+        /// <see cref="IList{IQueryNodeProcessor}.this[int]"/> 
+        /// </summary>
         public virtual IQueryNodeProcessor this[int index]
         {
             get
@@ -150,33 +154,34 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             }
         }
 
-        /**
-        * @see List#indexOf(Object)
-        */
+        /// <summary>
+        /// <see cref="IList{IQueryNodeProcessor}.IndexOf(IQueryNodeProcessor)"/>
+        /// </summary>
         public virtual int IndexOf(IQueryNodeProcessor o)
         {
             return this.processors.IndexOf(o);
         }
 
-        /**
-         * @see List#iterator()
-         */
+        /// <summary>
+        /// <see cref="IEnumerable{IQueryNodeProcessor}.GetEnumerator()"/>
+        /// </summary>
         public virtual IEnumerator<IQueryNodeProcessor> GetEnumerator()
         {
             return this.processors.GetEnumerator();
         }
 
-        /**
-         * @see List#remove(Object)
-         */
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Remove(IQueryNodeProcessor)"/> 
+        /// </summary>
         public virtual bool Remove(IQueryNodeProcessor o)
         {
             return this.processors.Remove(o);
         }
 
-        /**
-         * @see List#remove(int)
-         */
+        /// <summary>
+        /// <see cref="IList{IQueryNodeProcessor}.RemoveAt(int)"/> 
+        /// </summary>
+        /// <param name="index"></param>
         public virtual void RemoveAt(int index)
         {
             this.processors.RemoveAt(index);
@@ -187,9 +192,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             this.processors.RemoveRange(index, count);
         }
 
-        /**
-         * @see List#set(int, Object)
-         */
         public virtual IQueryNodeProcessor Set(int index, IQueryNodeProcessor processor)
         {
             IQueryNodeProcessor oldProcessor = this.processors[index];
@@ -203,11 +205,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             return oldProcessor;
         }
 
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Count"/> 
+        /// </summary>
         public virtual int Count
         {
             get { return this.processors.Count; }
         }
 
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.IsReadOnly"/> 
+        /// </summary>
         public virtual bool IsReadOnly
         {
             get
@@ -227,21 +235,34 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
             item.SetQueryConfigHandler(this.queryConfig);
         }
 
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Add(IQueryNodeProcessor)"/> 
+        /// </summary>
         void ICollection<IQueryNodeProcessor>.Add(IQueryNodeProcessor item)
         {
             this.Add(item);
         }
 
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.Contains(IQueryNodeProcessor)"/> 
+        /// </summary>
         public virtual bool Contains(IQueryNodeProcessor item)
         {
             return this.processors.Contains(item);
         }
 
+        /// <summary>
+        /// <see cref="ICollection{IQueryNodeProcessor}.CopyTo(IQueryNodeProcessor[], int)"/> 
+        /// </summary>
         public virtual void CopyTo(IQueryNodeProcessor[] array, int arrayIndex)
         {
             this.processors.CopyTo(array, arrayIndex);
         }
 
+        /// <summary>
+        /// <see cref="IEnumerable.GetEnumerator()"/> 
+        /// </summary>
+        /// <returns></returns>
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Processors/RemoveDeletedQueryNodesProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/RemoveDeletedQueryNodesProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/RemoveDeletedQueryNodesProcessor.cs
index 79103e1..1284ac2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Processors/RemoveDeletedQueryNodesProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Processors/RemoveDeletedQueryNodesProcessor.cs
@@ -21,9 +21,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Processors
      */
 
     /// <summary>
-    /// A {@link QueryNodeProcessorPipeline} class removes every instance of
-    /// {@link DeletedQueryNode} from a query node tree. If the resulting root node
-    /// is a {@link DeletedQueryNode}, {@link MatchNoDocsQueryNode} is returned.
+    /// A <see cref="QueryNodeProcessorPipeline"/> class removes every instance of
+    /// <see cref=""/> from a query node tree. If the resulting root node
+    /// is a <see cref="DeletedQueryNode"/>, <see cref="MatchNoDocsQueryNode"/> is returned.
     /// </summary>
     public class RemoveDeletedQueryNodesProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeError.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeError.cs b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeError.cs
index a07c8ed..b16b16e 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeError.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeError.cs
@@ -23,17 +23,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
     /// <summary>
     /// Error class with NLS support
     /// </summary>
-    /// <seealso cref="Messages.NLS"/>
-    /// <seealso cref="Messages.Message"/>
+    /// <seealso cref="NLS"/>
+    /// <seealso cref="IMessage"/>
     [Serializable]
     public class QueryNodeError : Exception, INLSException
     {
         private IMessage message;
 
-        /**
-         * @param message
-         *          - NLS Message Object
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="message">NLS Message Object</param>
         public QueryNodeError(IMessage message)
             : base(message.Key)
         {
@@ -41,32 +41,29 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
 
         }
 
-        /**
-         * @param throwable
-         *          - @see java.lang.Error
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="throwable">An exception instance to wrap</param>
         public QueryNodeError(Exception throwable)
             : base(throwable.Message, throwable)
         {
         }
 
-        /**
-         * @param message
-         *          - NLS Message Object
-         * @param throwable
-         *          - @see java.lang.Error
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="message">NLS Message Object</param>
+        /// <param name="throwable">An exception instance to wrap</param>
         public QueryNodeError(IMessage message, Exception throwable)
             : base(message.Key, throwable)
         {
             this.message = message;
         }
 
-        /*
-         * (non-Javadoc)
-         * 
-         * @see org.apache.lucene.messages.NLSException#getMessageObject()
-         */
+        /// <summary>
+        /// <see cref="INLSException.MessageObject"/> 
+        /// </summary>
         public virtual IMessage MessageObject
         {
             get { return this.message; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeException.cs b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeException.cs
index 3178300..1f9ceb0 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeException.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeException.cs
@@ -24,15 +24,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
 
     /// <summary>
     /// This exception should be thrown if something wrong happens when dealing with
-    /// {@link QueryNode}s.
+    /// <see cref="Nodes.IQueryNode"/>s.
     /// <para>
     /// It also supports NLS messages.
     /// </para>
     /// </summary>
-    /// <seealso cref="Message"/>
+    /// <seealso cref="IMessage"/>
     /// <seealso cref="NLS"/>
-    /// <seealso cref="NLSException"/>
-    /// <seealso cref="IQueryNode"/>
+    /// <seealso cref="INLSException"/>
+    /// <seealso cref="Nodes.IQueryNode"/>
     [Serializable]
     public class QueryNodeException : Exception, INLSException
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeParseException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeParseException.cs b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeParseException.cs
index cc88048..6eced96 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeParseException.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/QueryNodeParseException.cs
@@ -26,8 +26,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
     /// string to the query node tree.
     /// </summary>
     /// <seealso cref="QueryNodeException"/>
-    /// <seealso cref="ISyntaxParser"/>
-    /// <seealso cref="IQueryNode"/>
+    /// <seealso cref="Parser.ISyntaxParser"/>
+    /// <seealso cref="Nodes.IQueryNode"/>
     [Serializable]
     public class QueryNodeParseException : QueryNodeException
     {
@@ -80,26 +80,24 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
             this.message = message;
         }
 
-        /**
-         * For EndOfLine and EndOfFile ("&lt;EOF&gt;") parsing problems the last char in the
-         * string is returned For the case where the parser is not able to figure out
-         * the line and column number -1 will be returned
-         * 
-         * @return line where the problem was found
-         */
+        /// <summary>
+        /// For EndOfLine and EndOfFile ("&lt;EOF&gt;") parsing problems the last char in the
+        /// string is returned. For the case where the parser is not able to figure out
+        /// the line and column number -1 will be returned.
+        /// Returns line where the problem was found.
+        /// </summary>
         public virtual int BeginLine
         {
             get { return this.beginLine; }
             protected set { this.beginLine = value; }
         }
 
-        /**
-         * For EndOfLine and EndOfFile ("&lt;EOF&gt;") parsing problems the last char in the
-         * string is returned For the case where the parser is not able to figure out
-         * the line and column number -1 will be returned
-         * 
-         * @return column of the first char where the problem was found
-         */
+        /// <summary>
+        /// For EndOfLine and EndOfFile ("&lt;EOF&gt;") parsing problems the last char in the
+        /// string is returned. For the case where the parser is not able to figure out
+        /// the line and column number -1 will be returned. 
+        /// Returns column of the first char where the problem was found.
+        /// </summary>
         public virtual int BeginColumn
         {
             get { return this.beginColumn; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/QueryParserHelper.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/QueryParserHelper.cs b/src/Lucene.Net.QueryParser/Flexible/Core/QueryParserHelper.cs
index 76f8cf6..d2ba77e 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/QueryParserHelper.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/QueryParserHelper.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
     /// </summary>
     /// <seealso cref="IQueryNodeProcessor"/>
     /// <seealso cref="ISyntaxParser"/>
-    /// <seealso cref="QueryBuilder"/>
+    /// <seealso cref="Builders.IQueryBuilder{TQuery}"/>
     /// <seealso cref="Config.QueryConfigHandler"/>
     public class QueryParserHelper<TQuery> // LUCENENET: Made this class generic so we can avoid the cast (to Query) on the Parse method
     {
@@ -47,25 +47,18 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
 
         private QueryConfigHandler config;
 
-        /**
-         * Creates a query parser helper object using the specified configuration,
-         * text parser, processor and builder.
-         * 
-         * @param queryConfigHandler
-         *          the query configuration handler that will be initially set to this
-         *          helper
-         * @param syntaxParser
-         *          the text parser that will be initially set to this helper
-         * @param processor
-         *          the query processor that will be initially set to this helper
-         * @param builder
-         *          the query builder that will be initially set to this helper
-         * 
-         * @see QueryNodeProcessor
-         * @see SyntaxParser
-         * @see QueryBuilder
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// Creates a query parser helper object using the specified configuration,
+        /// text parser, processor and builder.
+        /// </summary>
+        /// <param name="queryConfigHandler">the query configuration handler that will be initially set to this helper</param>
+        /// <param name="syntaxParser">the text parser that will be initially set to this helper</param>
+        /// <param name="processor">the query processor that will be initially set to this helper</param>
+        /// <param name="builder">the query builder that will be initially set to this helper</param>
+        /// <seealso cref="IQueryNodeProcessor"/>
+        /// <seealso cref="ISyntaxParser"/>
+        /// <seealso cref="IQueryBuilder{TQuery}"/>
+        /// <seealso cref="Config.QueryConfigHandler"/>
         public QueryParserHelper(QueryConfigHandler queryConfigHandler, ISyntaxParser syntaxParser, IQueryNodeProcessor processor,
             IQueryBuilder<TQuery> builder)
         {
@@ -80,51 +73,41 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
             }
         }
 
-        /**
-         * Returns the processor object used to process the query node tree, it
-         * returns <code>null</code> if no processor is used.
-         * 
-         * @return the actual processor used to process the query node tree,
-         *         <code>null</code> if no processor is used
-         * 
-         * @see QueryNodeProcessor
-         * @see #setQueryNodeProcessor(QueryNodeProcessor)
-         */
+        /// <summary>
+        /// Gets the processor object used to process the query node tree, it
+        /// returns <c>null</c> if no processor is used.
+        /// </summary>
+        /// <seealso cref="IQueryNodeProcessor"/>.
+        /// <seealso cref="SetQueryNodeProcessor(IQueryNodeProcessor)"/>
         public virtual IQueryNodeProcessor QueryNodeProcessor
         {
             get { return processor; }
         }
 
-        /**
-         * Sets the processor that will be used to process the query node tree. If
-         * there is any {@link QueryConfigHandler} returned by
-         * {@link #getQueryConfigHandler()}, it will be set on the processor. The
-         * argument can be <code>null</code>, which means that no processor will be
-         * used to process the query node tree.
-         * 
-         * @param processor
-         *          the processor that will be used to process the query node tree,
-         *          this argument can be <code>null</code>
-         * 
-         * @see #getQueryNodeProcessor()
-         * @see QueryNodeProcessor
-         */
+        /// <summary>
+        /// Sets the processor that will be used to process the query node tree. If
+        /// there is any <see cref="Config.QueryConfigHandler"/> returned by
+        /// <see cref="QueryConfigHandler"/>, it will be set on the processor. The
+        /// argument can be <c>null</c>, which means that no processor will be
+        /// used to process the query node tree.
+        /// </summary>
+        /// <param name="processor">the processor that will be used to process the query node tree,
+        /// this argument can be <c>null</c></param>
+        /// <seealso cref="QueryNodeProcessor"/>
+        /// <seealso cref="IQueryNodeProcessor"/>
         public virtual void SetQueryNodeProcessor(IQueryNodeProcessor processor)
         {
             this.processor = processor;
             this.processor.SetQueryConfigHandler(QueryConfigHandler);
         }
 
-        /**
-         * Sets the text parser that will be used to parse the query string, it cannot
-         * be <code>null</code>.
-         * 
-         * @param syntaxParser
-         *          the text parser that will be used to parse the query string
-         * 
-         * @see #getSyntaxParser()
-         * @see SyntaxParser
-         */
+        /// <summary>
+        /// Sets the text parser that will be used to parse the query string, it cannot
+        /// be <c>null</c>.
+        /// </summary>
+        /// <param name="syntaxParser">the text parser that will be used to parse the query string</param>
+        /// <seealso cref="SyntaxParser"/>
+        /// <seealso cref="ISyntaxParser"/>
         public virtual void SetSyntaxParser(ISyntaxParser syntaxParser)
         {
             if (syntaxParser == null)
@@ -135,16 +118,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
             this.syntaxParser = syntaxParser;
         }
 
-        /**
-         * The query builder that will be used to build an object from the query node
-         * tree. It cannot be <code>null</code>.
-         * 
-         * @param queryBuilder
-         *          the query builder used to build something from the query node tree
-         * 
-         * @see #getQueryBuilder()
-         * @see QueryBuilder
-         */
+        /// <summary>
+        /// The query builder that will be used to build an object from the query node
+        /// tree. It cannot be <c>null</c>.
+        /// </summary>
+        /// <param name="queryBuilder">the query builder used to build something from the query node tree</param>
+        /// <seealso cref="QueryBuilder"/>
+        /// <seealso cref="IQueryBuilder{TQuery}"/>
         public virtual void SetQueryBuilder(IQueryBuilder<TQuery> queryBuilder)
         {
             if (queryBuilder == null)
@@ -155,63 +135,49 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
             this.builder = queryBuilder;
         }
 
-        /**
-         * Returns the query configuration handler, which is used during the query
-         * node tree processing. It can be <code>null</code>.
-         * 
-         * @return the query configuration handler used on the query processing,
-         *         <code>null</code> if not query configuration handler is defined
-         * 
-         * @see QueryConfigHandler
-         * @see #setQueryConfigHandler(QueryConfigHandler)
-         */
+        /// <summary>
+        /// Returns the query configuration handler, which is used during the query
+        /// node tree processing. It can be <c>null</c>.
+        /// </summary>
+        /// <seealso cref="Config.QueryConfigHandler"/>
+        /// <seealso cref="SetQueryConfigHandler(QueryConfigHandler)"/>
         public virtual QueryConfigHandler QueryConfigHandler
         {
             get { return config; }
         }
 
-        /**
-         * Returns the query builder used to build a object from the query node tree.
-         * The object produced by this builder is returned by
-         * {@link #parse(String, String)}.
-         * 
-         * @return the query builder
-         * 
-         * @see #setQueryBuilder(QueryBuilder)
-         * @see QueryBuilder
-         */
+        /// <summary>
+        /// Returns the query builder used to build a object from the query node tree.
+        /// The object produced by this builder is returned by <see cref="Parse(string, string)"/>.
+        /// </summary>
+        /// <seealso cref="SetQueryBuilder(IQueryBuilder{TQuery})"/>
+        /// <seealso cref="IQueryBuilder{TQuery}"/>
         public virtual IQueryBuilder<TQuery> QueryBuilder
         {
             get { return this.builder; }
         }
 
-        /**
-         * Returns the text parser used to build a query node tree from a query
-         * string. The default text parser instance returned by this method is a
-         * {@link SyntaxParser}.
-         * 
-         * @return the text parse used to build query node trees.
-         * 
-         * @see SyntaxParser
-         * @see #setSyntaxParser(SyntaxParser)
-         */
+        /// <summary>
+        /// Returns the text parser used to build a query node tree from a query
+        /// string. The default text parser instance returned by this method is a
+        /// <see cref="ISyntaxParser"/>.
+        /// </summary>
+        /// <seealso cref="ISyntaxParser"/>
+        /// <seealso cref="SetSyntaxParser(ISyntaxParser)"/>
         public virtual ISyntaxParser SyntaxParser
         {
             get { return this.syntaxParser; }
         }
 
-        /**
-         * Sets the query configuration handler that will be used during query
-         * processing. It can be <code>null</code>. It's also set to the processor
-         * returned by {@link #getQueryNodeProcessor()}.
-         * 
-         * @param config
-         *          the query configuration handler used during query processing, it
-         *          can be <code>null</code>
-         * 
-         * @see #getQueryConfigHandler()
-         * @see QueryConfigHandler
-         */
+        /// <summary>
+        /// Sets the query configuration handler that will be used during query
+        /// processing. It can be <c>null</c>. It's also set to the processor
+        /// returned by <see cref="QueryNodeProcessor"/>.
+        /// </summary>
+        /// <param name="config">the query configuration handler used during query processing, it
+        /// can be <c>null</c></param>
+        /// <seealso cref="QueryConfigHandler"/>
+        /// <seealso cref="Config.QueryConfigHandler"/>
         public virtual void SetQueryConfigHandler(QueryConfigHandler config)
         {
             this.config = config;
@@ -223,31 +189,25 @@ namespace Lucene.Net.QueryParsers.Flexible.Core
             }
         }
 
-        /**
-         * Parses a query string to an object, usually some query object. <br/>
-         * <br/>
-         * In this method the three phases are executed: <br/>
-         * <br/>
-         * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1st - the query string is parsed using the
-         * text parser returned by {@link #getSyntaxParser()}, the result is a query
-         * node tree <br/>
-         * <br/>
-         * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2nd - the query node tree is processed by the
-         * processor returned by {@link #getQueryNodeProcessor()} <br/>
-         * <br/>
-         * &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;3th - a object is built from the query node
-         * tree using the builder returned by {@link #getQueryBuilder()}
-         * 
-         * @param query
-         *          the query string
-         * @param defaultField
-         *          the default field used by the text parser
-         * 
-         * @return the object built from the query
-         * 
-         * @throws QueryNodeException
-         *           if something wrong happens along the three phases
-         */
+        /// <summary>
+        /// Parses a query string to an object, usually some query object.
+        /// <para/>
+        /// In this method the three phases are executed:
+        /// <para/>
+        /// &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1st - the query string is parsed using the
+        /// text parser returned by <see cref="SyntaxParser"/>, the result is a query
+        /// node tree
+        /// <para/>
+        /// &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2nd - the query node tree is processed by the
+        /// processor returned by <see cref="QueryNodeProcessor"/>
+        /// <para/>
+        /// &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;3th - a object is built from the query node
+        /// tree using the builder returned by <see cref="QueryBuilder"/>
+        /// </summary>
+        /// <param name="query">the query string</param>
+        /// <param name="defaultField">the default field used by the text parser</param>
+        /// <returns>the object built from the query</returns>
+        /// <exception cref="QueryNodeException">if something wrong happens along the three phases</exception>
         public virtual TQuery Parse(string query, string defaultField)
         {
             IQueryNode queryTree = SyntaxParser.Parse(query, defaultField);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Util/QueryNodeOperation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Util/QueryNodeOperation.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Util/QueryNodeOperation.cs
index dbc470e..8f8a241 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Util/QueryNodeOperation.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Util/QueryNodeOperation.cs
@@ -35,15 +35,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             BOTH, Q1, Q2, NONE
         }
 
-        /**
-         * perform a logical and of 2 QueryNode trees. if q1 and q2 are ANDQueryNode
-         * nodes it uses head Node from q1 and adds the children of q2 to q1 if q1 is
-         * a AND node and q2 is not, add q2 as a child of the head node of q1 if q2 is
-         * a AND node and q1 is not, add q1 as a child of the head node of q2 if q1
-         * and q2 are not ANDQueryNode nodes, create a AND node and make q1 and q2
-         * children of that node if q1 or q2 is null it returns the not null node if
-         * q1 = q2 = null it returns null
-         */
+        /// <summary>
+        /// perform a logical and of 2 QueryNode trees. if q1 and q2 are ANDQueryNode
+        /// nodes it uses head Node from q1 and adds the children of q2 to q1 if q1 is
+        /// a AND node and q2 is not, add q2 as a child of the head node of q1 if q2 is
+        /// a AND node and q1 is not, add q1 as a child of the head node of q2 if q1
+        /// and q2 are not ANDQueryNode nodes, create a AND node and make q1 and q2
+        /// children of that node if q1 or q2 is null it returns the not null node if
+        /// q1 = q2 = null it returns null
+        /// </summary>
         public static IQueryNode LogicalAnd(IQueryNode q1, IQueryNode q2)
         {
             if (q1 == null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Core/Util/UnescapedCharSequence.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Core/Util/UnescapedCharSequence.cs b/src/Lucene.Net.QueryParser/Flexible/Core/Util/UnescapedCharSequence.cs
index 6b05a60..3de67f8 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Core/Util/UnescapedCharSequence.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Core/Util/UnescapedCharSequence.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
      */
 
     /// <summary>
-    /// CharsSequence with escaped chars information.
+    /// <see cref="ICharSequence"/> with escaped chars information.
     /// </summary>
     public sealed class UnescapedCharSequence : ICharSequence
     {
@@ -30,9 +30,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
 
         private bool[] wasEscaped;
 
-        /**
-         * Create a escaped CharSequence
-         */
+        /// <summary>
+        /// Create a escaped <see cref="ICharSequence"/>
+        /// </summary>
         public UnescapedCharSequence(char[] chars, bool[] wasEscaped, int offset,
             int length)
         {
@@ -42,9 +42,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             System.Array.Copy(wasEscaped, offset, this.wasEscaped, 0, length);
         }
 
-        /**
-         * Create a non-escaped CharSequence
-         */
+        /// <summary>
+        /// Create a non-escaped <see cref="ICharSequence"/>
+        /// </summary>
         public UnescapedCharSequence(ICharSequence text)
         {
             this.chars = new char[text.Length];
@@ -56,9 +56,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             }
         }
 
-        /**
-         * Create a non-escaped CharSequence
-         */
+        /// <summary>
+        /// Create a non-escaped <see cref="ICharSequence"/>
+        /// </summary>
          // LUCENENET specific overload for text as string
         public UnescapedCharSequence(string text)
         {
@@ -71,9 +71,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             }
         }
 
-        /**
-         * Create a copy of an existent UnescapedCharSequence
-         */
+        /// <summary>
+        /// Create a copy of an existent <see cref="UnescapedCharSequence"/>
+        /// </summary>
         private UnescapedCharSequence(UnescapedCharSequence text)
         {
             this.chars = new char[text.Length];
@@ -117,11 +117,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             return new string(this.chars);
         }
 
-        /**
-         * Return a escaped String
-         * 
-         * @return a escaped String
-         */
+        /// <summary>
+        /// Return an escaped <see cref="string"/>
+        /// </summary>
+        /// <returns>an escaped <see cref="string"/></returns>
         public string ToStringEscaped()
         {
             // non efficient implementation
@@ -140,13 +139,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Core.Util
             return result.ToString();
         }
 
-        /**
-         * Return a escaped String
-         * 
-         * @param enabledChars
-         *          - array of chars to be escaped
-         * @return a escaped String
-         */
+        /// <summary>
+        /// Return an escaped <see cref="string"/>
+        /// </summary>
+        /// <param name="enabledChars">array of chars to be escaped</param>
+        /// <returns>an escaped <see cref="string"/></returns>
         public ICharSequence ToStringEscaped(char[] enabledChars)
         {
             // TODO: non efficient implementation, refactor this code

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Messages/MessageImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Messages/MessageImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Messages/MessageImpl.cs
index 5d326f6..1af997a 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Messages/MessageImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Messages/MessageImpl.cs
@@ -42,31 +42,26 @@ namespace Lucene.Net.QueryParsers.Flexible.Messages
             this.arguments = args;
         }
 
-
         public virtual object[] GetArguments()
         {
             return this.arguments;
         }
 
-
         public virtual string Key
         {
             get { return this.key; }
         }
 
-
         public virtual string GetLocalizedMessage()
         {
             return GetLocalizedMessage(CultureInfo.CurrentUICulture);
         }
 
-
         public virtual string GetLocalizedMessage(CultureInfo locale)
         {
             return NLS.GetLocalizedMessage(Key, locale, GetArguments());
         }
 
-
         public override string ToString()
         {
             object[] args = GetArguments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Messages/NLS.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Messages/NLS.cs b/src/Lucene.Net.QueryParser/Flexible/Messages/NLS.cs
index 9693891..17d5a13 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Messages/NLS.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Messages/NLS.cs
@@ -81,15 +81,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Messages
             return GetLocalizedMessage(key, CultureInfo.CurrentUICulture, args);
         }
 
-        /**
-         * Initialize a given class with the message bundle Keys Should be called from
-         * a class that extends NLS in a static block at class load time.
-         * 
-         * @param bundleName
-         *          Property file with that contains the message bundle
-         * @param clazz
-         *          where constants will reside
-         */
+        /// <summary>
+        /// Initialize a given class with the message bundle Keys Should be called from
+        /// a class that extends NLS in a static block at class load time.
+        /// </summary>
+        /// <param name="bundleName">Property file with that contains the message bundle</param>
+        /// <param name="clazz">where constants will reside</param>
         protected static void InitializeMessages(string bundleName, Type clazz)
         {
             try
@@ -155,10 +152,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Messages
             ValidateMessage(field.Name, clazz);
         }
 
-        /**
-         * @param key
-         *          - Message Key
-         */
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key">Message Key</param>
+        /// <param name="clazz"></param>
         private static void ValidateMessage(string key, Type clazz)
         {
             // Test if the message is present in the resource bundle

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Precedence/PrecedenceQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Precedence/PrecedenceQueryParser.cs b/src/Lucene.Net.QueryParser/Flexible/Precedence/PrecedenceQueryParser.cs
index d10baf9..d660060 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Precedence/PrecedenceQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Precedence/PrecedenceQueryParser.cs
@@ -22,28 +22,28 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence
      */
 
     /// <summary>
-    /// This query parser works exactly as the standard query parser ( {@link StandardQueryParser} ), 
+    /// This query parser works exactly as the standard query parser ( <see cref="StandardQueryParser"/> ), 
     /// except that it respect the boolean precedence, so &lt;a AND b OR c AND d&gt; is parsed to &lt;(+a +b) (+c +d)&gt;
     /// instead of &lt;+a +b +c +d&gt;.
     /// <para>
-    /// EXPERT: This class extends {@link StandardQueryParser}, but uses {@link PrecedenceQueryNodeProcessorPipeline}
-    /// instead of {@link StandardQueryNodeProcessorPipeline} to process the query tree.
+    /// EXPERT: This class extends <see cref="StandardQueryParser"/>, but uses <see cref="PrecedenceQueryNodeProcessorPipeline"/>
+    /// instead of <see cref="Standard.Processors.StandardQueryNodeProcessorPipeline"/> to process the query tree.
     /// </para>
     /// </summary>
     /// <seealso cref="StandardQueryParser"/>
     public class PrecedenceQueryParser : StandardQueryParser
     {
-        /**
-   * @see StandardQueryParser#StandardQueryParser()
-   */
+        /// <summary>
+        /// <see cref="StandardQueryParser.StandardQueryParser()"/> 
+        /// </summary>
         public PrecedenceQueryParser()
         {
             SetQueryNodeProcessor(new PrecedenceQueryNodeProcessorPipeline(QueryConfigHandler));
         }
 
-        /**
-         * @see StandardQueryParser#StandardQueryParser(Analyzer)
-         */
+        /// <summary>
+        /// <see cref="StandardQueryParser.StandardQueryParser(Analyzer)"/>
+        /// </summary>
         public PrecedenceQueryParser(Analyzer analyer)
             : base(analyer)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/BooleanModifiersQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/BooleanModifiersQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/BooleanModifiersQueryNodeProcessor.cs
index 8e9a1bb..85b05d7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/BooleanModifiersQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/BooleanModifiersQueryNodeProcessor.cs
@@ -25,17 +25,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence.Processors
      */
 
     /// <summary>
-    /// This processor is used to apply the correct {@link ModifierQueryNode} to {@link BooleanQueryNode}s children.
+    /// This processor is used to apply the correct <see cref="ModifierQueryNode"/> to <see cref="BooleanQueryNode"/>s children.
     /// <para>
-    /// It walks through the query node tree looking for {@link BooleanQueryNode}s. If an {@link AndQueryNode} is found,
-    /// every child, which is not a {@link ModifierQueryNode} or the {@link ModifierQueryNode} 
-    /// is {@link Modifier#MOD_NONE}, becomes a {@link Modifier#MOD_REQ}. For any other
-    /// {@link BooleanQueryNode} which is not an {@link OrQueryNode}, it checks the default operator is {@link Operator#AND},
-    /// if it is, the same operation when an {@link AndQueryNode} is found is applied to it.
+    /// It walks through the query node tree looking for <see cref="BooleanQueryNode"/>s. If an <see cref="AndQueryNode"/> is found,
+    /// every child, which is not a <see cref="ModifierQueryNode"/> or the <see cref="ModifierQueryNode"/> 
+    /// is <see cref="Modifier.MOD_NONE"/>, becomes a <see cref="Modifier.MOD_REQ"/>. For any other
+    /// <see cref="BooleanQueryNode"/> which is not an <see cref="OrQueryNode"/>, it checks the default operator is <see cref="Operator.AND"/>,
+    /// if it is, the same operation when an <see cref="AndQueryNode"/> is found is applied to it.
     /// </para>
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#DEFAULT_OPERATOR"/>
-    /// <seealso cref="PrecedenceQueryParser#setDefaultOperator"/>
+    /// <seealso cref="ConfigurationKeys.DEFAULT_OPERATOR"/>
     public class BooleanModifiersQueryNodeProcessor : QueryNodeProcessorImpl
     {
         private List<IQueryNode> childrenBuffer = new List<IQueryNode>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/PrecedenceQueryNodeProcessorPipeline.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/PrecedenceQueryNodeProcessorPipeline.cs b/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/PrecedenceQueryNodeProcessorPipeline.cs
index dc9d03d..71a2cd9 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/PrecedenceQueryNodeProcessorPipeline.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Precedence/Processors/PrecedenceQueryNodeProcessorPipeline.cs
@@ -21,11 +21,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence.Processors
      */
 
     /// <summary>
-    /// This processor pipeline extends {@link StandardQueryNodeProcessorPipeline} and enables
+    /// This processor pipeline extends <see cref="StandardQueryNodeProcessorPipeline"/> and enables
     /// boolean precedence on it.
     /// <para>
-    /// EXPERT: the precedence is enabled by removing {@link GroupQueryNodeProcessor} from the
-    /// {@link StandardQueryNodeProcessorPipeline} and appending {@link BooleanModifiersQueryNodeProcessor}
+    /// EXPERT: the precedence is enabled by removing <see cref="GroupQueryNodeProcessor"/> from the
+    /// <see cref="StandardQueryNodeProcessorPipeline"/> and appending <see cref="BooleanModifiersQueryNodeProcessor"/>
     /// to the pipeline.
     /// </para>
     /// </summary>
@@ -33,9 +33,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Precedence.Processors
     /// <seealso cref="StandardQueryNodeProcessorPipeline"/>
     public class PrecedenceQueryNodeProcessorPipeline : StandardQueryNodeProcessorPipeline
     {
-        /**
-   * @see StandardQueryNodeProcessorPipeline#StandardQueryNodeProcessorPipeline(QueryConfigHandler)
-   */
+        /// <summary>
+        /// <see cref="StandardQueryNodeProcessorPipeline.StandardQueryNodeProcessorPipeline(QueryConfigHandler)"/>
+        /// </summary>
         public PrecedenceQueryNodeProcessorPipeline(QueryConfigHandler queryConfig)
             : base(queryConfig)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/AnyQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/AnyQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/AnyQueryNodeBuilder.cs
index e3c09ab..cb6f1d1 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/AnyQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/AnyQueryNodeBuilder.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a BooleanQuery of SHOULD clauses, possibly with
+    /// Builds a <see cref="BooleanQuery"/> of SHOULD clauses, possibly with
     /// some minimum number to match.
     /// </summary>
     public class AnyQueryNodeBuilder : IStandardQueryBuilder
@@ -60,10 +60,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
                         catch (BooleanQuery.TooManyClauses ex)
                         {
                             throw new QueryNodeException(new MessageImpl(
-                               /*
-                                * IQQQ.Q0028E_TOO_MANY_BOOLEAN_CLAUSES,
-                                * BooleanQuery.getMaxClauseCount()
-                                */QueryParserMessages.EMPTY_MESSAGE), ex);
+                                /*
+                                 * IQQQ.Q0028E_TOO_MANY_BOOLEAN_CLAUSES,
+                                 * BooleanQuery.getMaxClauseCount()
+                                 */QueryParserMessages.EMPTY_MESSAGE), ex);
                         }
                     }
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BooleanQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BooleanQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BooleanQueryNodeBuilder.cs
index 8f29be5..4c849db 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BooleanQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BooleanQueryNodeBuilder.cs
@@ -27,13 +27,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link BooleanQuery} object from a {@link BooleanQueryNode} object.
-    /// Every children in the {@link BooleanQueryNode} object must be already tagged
-    /// using {@link QueryTreeBuilder#QUERY_TREE_BUILDER_TAGID} with a {@link Query}
+    /// Builds a <see cref="BooleanQuery"/> object from a <see cref="BooleanQueryNode"/> object.
+    /// Every children in the <see cref="BooleanQueryNode"/> object must be already tagged
+    /// using <see cref="QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID"/> with a <see cref="Query"/>
     /// object.
     /// <para>
-    /// It takes in consideration if the children is a {@link ModifierQueryNode} to
-    /// define the {@link BooleanClause}.
+    /// It takes in consideration if the children is a <see cref="ModifierQueryNode"/> to
+    /// define the <see cref="BooleanClause"/>.
     /// </para>
     /// </summary>
     public class BooleanQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BoostQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BoostQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BoostQueryNodeBuilder.cs
index afa01ab..53fcc9f 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BoostQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/BoostQueryNodeBuilder.cs
@@ -22,10 +22,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// This builder basically reads the {@link Query} object set on the
-    /// {@link BoostQueryNode} child using
-    /// {@link QueryTreeBuilder#QUERY_TREE_BUILDER_TAGID} and applies the boost value
-    /// defined in the {@link BoostQueryNode}.
+    /// This builder basically reads the <see cref="Query"/> object set on the
+    /// <see cref="BoostQueryNode"/> child using
+    /// <see cref="QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID"/> and applies the boost value
+    /// defined in the <see cref="BoostQueryNode"/>.
     /// </summary>
     public class BoostQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/DummyQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/DummyQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/DummyQueryNodeBuilder.cs
index 7a86b52..c2e8e7d 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/DummyQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/DummyQueryNodeBuilder.cs
@@ -21,15 +21,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// This builder does nothing. Commonly used for {@link QueryNode} objects that
+    /// This builder does nothing. Commonly used for <see cref="IQueryNode"/> objects that
     /// are built by its parent's builder.
     /// </summary>
     /// <seealso cref="IStandardQueryBuilder"/>
-    /// <seealso cref="QueryTreeBuilder"/>
+    /// <seealso cref="Core.Builders.QueryTreeBuilder{TQuery}"/>
     public class DummyQueryNodeBuilder : IStandardQueryBuilder
     {
         /// <summary>
-        /// Constructs a {@link DummyQueryNodeBuilder} object.
+        /// Constructs a <see cref="DummyQueryNodeBuilder"/> object.
         /// </summary>
         public DummyQueryNodeBuilder()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FieldQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FieldQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FieldQueryNodeBuilder.cs
index c8da71b..d0b10a4 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FieldQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FieldQueryNodeBuilder.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link TermQuery} object from a {@link FieldQueryNode} object.
+    /// Builds a <see cref="TermQuery"/> object from a <see cref="FieldQueryNode"/> object.
     /// </summary>
     public class FieldQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
index 9215ac5..e0a9a61 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link FuzzyQuery} object from a {@link FuzzyQueryNode} object.
+    /// Builds a <see cref="FuzzyQuery"/> object from a <see cref="FuzzyQueryNode"/> object.
     /// </summary>
     public class FuzzyQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/GroupQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/GroupQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/GroupQueryNodeBuilder.cs
index 69490b6..68ad84c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/GroupQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/GroupQueryNodeBuilder.cs
@@ -22,9 +22,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds no object, it only returns the {@link Query} object set on the
-    /// {@link GroupQueryNode} object using a
-    /// {@link QueryTreeBuilder#QUERY_TREE_BUILDER_TAGID} tag.
+    /// Builds no object, it only returns the <see cref="Query"/> object set on the
+    /// <see cref="GroupQueryNode"/> object using a
+    /// <see cref="QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID"/> tag.
     /// </summary>
     public class GroupQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchAllDocsQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchAllDocsQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchAllDocsQueryNodeBuilder.cs
index fe079d5..21381bb 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchAllDocsQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchAllDocsQueryNodeBuilder.cs
@@ -25,8 +25,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link MatchAllDocsQuery} object from a
-    /// {@link MatchAllDocsQueryNode} object.
+    /// Builds a <see cref="MatchAllDocsQuery"/> object from a
+    /// <see cref="MatchAllDocsQueryNode"/> object.
     /// </summary>
     public class MatchAllDocsQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchNoDocsQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchNoDocsQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchNoDocsQueryNodeBuilder.cs
index 1889513..8d52cba 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchNoDocsQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MatchNoDocsQueryNodeBuilder.cs
@@ -25,8 +25,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds an empty {@link BooleanQuery} object from a
-    /// {@link MatchNoDocsQueryNode} object.
+    /// Builds an empty <see cref="BooleanQuery"/> object from a
+    /// <see cref="MatchNoDocsQueryNode"/> object.
     /// </summary>
     public class MatchNoDocsQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/ModifierQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/ModifierQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/ModifierQueryNodeBuilder.cs
index f7f9572..e13eef2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/ModifierQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/ModifierQueryNodeBuilder.cs
@@ -22,9 +22,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds no object, it only returns the {@link Query} object set on the
-    /// {@link ModifierQueryNode} object using a
-    /// {@link QueryTreeBuilder#QUERY_TREE_BUILDER_TAGID} tag.
+    /// Builds no object, it only returns the <see cref="Query"/> object set on the
+    /// <see cref="ModifierQueryNode"/> object using a
+    /// <see cref="QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID"/> tag.
     /// </summary>
     public class ModifierQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MultiPhraseQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MultiPhraseQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MultiPhraseQueryNodeBuilder.cs
index 6eb883c..38eb07b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MultiPhraseQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/MultiPhraseQueryNodeBuilder.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link MultiPhraseQuery} object from a {@link MultiPhraseQueryNode}
+    /// Builds a <see cref="MultiPhraseQuery"/> object from a <see cref="MultiPhraseQueryNode"/>
     /// object.
     /// </summary>
     public class MultiPhraseQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
index 51b4eef..ce1be4e 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
@@ -28,15 +28,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds {@link NumericRangeQuery}s out of {@link NumericRangeQueryNode}s.
+    /// Builds <see cref="NumericRangeQuery"/>s out of <see cref="NumericRangeQueryNode"/>s.
     /// </summary>
     /// <seealso cref="NumericRangeQuery"/>
     /// <seealso cref="NumericRangeQueryNode"/>
     public class NumericRangeQueryNodeBuilder : IStandardQueryBuilder
     {
-        /**
-   * Constructs a {@link NumericRangeQueryNodeBuilder} object.
-   */
+        /// <summary>
+        /// Constructs a <see cref="NumericRangeQueryNodeBuilder"/> object.
+        /// </summary>
         public NumericRangeQueryNodeBuilder()
         {
             // empty constructor

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PhraseQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PhraseQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PhraseQueryNodeBuilder.cs
index 79f3dba..a515053 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PhraseQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PhraseQueryNodeBuilder.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link PhraseQuery} object from a {@link TokenizedPhraseQueryNode}
+    /// Builds a <see cref="PhraseQuery"/> object from a <see cref="TokenizedPhraseQueryNode"/>
     /// object.
     /// </summary>
     public class PhraseQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PrefixWildcardQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PrefixWildcardQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PrefixWildcardQueryNodeBuilder.cs
index c9c0352..7473c6a 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PrefixWildcardQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/PrefixWildcardQueryNodeBuilder.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link PrefixQuery} object from a {@link PrefixWildcardQueryNode}
+    /// Builds a <see cref="PrefixQuery"/> object from a <see cref="PrefixWildcardQueryNode"/>
     /// object.
     /// </summary>
     public class PrefixWildcardQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/RegexpQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/RegexpQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/RegexpQueryNodeBuilder.cs
index 956a3e5..7db6650 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/RegexpQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/RegexpQueryNodeBuilder.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link RegexpQuery} object from a {@link RegexpQueryNode} object.
+    /// Builds a <see cref="RegexpQuery"/> object from a <see cref="RegexpQueryNode"/> object.
     /// </summary>
     public class RegexpQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/SlopQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/SlopQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/SlopQueryNodeBuilder.cs
index bf3156e..d58cf70 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/SlopQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/SlopQueryNodeBuilder.cs
@@ -22,10 +22,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// This builder basically reads the {@link Query} object set on the
-    /// {@link SlopQueryNode} child using
-    /// {@link QueryTreeBuilder#QUERY_TREE_BUILDER_TAGID} and applies the slop value
-    /// defined in the {@link SlopQueryNode}.
+    /// This builder basically reads the <see cref="Query"/> object set on the
+    /// <see cref="SlopQueryNode"/> child using
+    /// <see cref="QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID"/> and applies the slop value
+    /// defined in the <see cref="SlopQueryNode"/>.
     /// </summary>
     public class SlopQueryNodeBuilder : IStandardQueryBuilder
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardBooleanQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardBooleanQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardBooleanQueryNodeBuilder.cs
index 428a75e..fe3f30c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardBooleanQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardBooleanQueryNodeBuilder.cs
@@ -28,13 +28,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// This builder does the same as the {@link BooleanQueryNodeBuilder}, but this
-    /// considers if the built {@link BooleanQuery} should have its coord disabled or
+    /// This builder does the same as the <see cref="BooleanQueryNodeBuilder"/>, but this
+    /// considers if the built <see cref="BooleanQuery"/> should have its coord disabled or
     /// not.
     /// </summary>
     /// <seealso cref="BooleanQueryNodeBuilder"/>
     /// <seealso cref="BooleanQuery"/>
-    /// <seealso cref="Similarity#coord(int, int)"/>
+    /// <seealso cref="Search.Similarities.Similarity.Coord(int, int)"/>
     public class StandardBooleanQueryNodeBuilder : IStandardQueryBuilder
     {
         public StandardBooleanQueryNodeBuilder()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryBuilder.cs
index 4c15b8e..4bb8997 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryBuilder.cs
@@ -22,9 +22,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
 
     /// <summary>
     /// This interface should be implemented by every class that wants to build
-    /// {@link Query} objects from {@link QueryNode} objects. 
+    /// <see cref="Query"/> objects from <see cref="Core.Nodes.IQueryNode"/> objects. 
     /// </summary>
-    /// <seealso cref="IQueryBuilder"/>
+    /// <seealso cref="IQueryBuilder{TQuery}"/>
     /// <seealso cref="QueryTreeBuilder"/>
     public interface IStandardQueryBuilder : IQueryBuilder<Query>
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryTreeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryTreeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryTreeBuilder.cs
index b589d7b..265b059 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryTreeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/StandardQueryTreeBuilder.cs
@@ -24,12 +24,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
 
     /// <summary>
     /// This query tree builder only defines the necessary map to build a
-    /// {@link Query} tree object. It should be used to generate a {@link Query} tree
+    /// <see cref="Query"/> tree object. It should be used to generate a <see cref="Query"/> tree
     /// object from a query node tree processed by a
-    /// {@link StandardQueryNodeProcessorPipeline}.
+    /// <see cref="Processors.StandardQueryNodeProcessorPipeline"/>.
     /// </summary>
     /// <seealso cref="QueryTreeBuilder"/>
-    /// <seealso cref="StandardQueryNodeProcessorPipeline"/>
+    /// <seealso cref="Processors.StandardQueryNodeProcessorPipeline"/>
     public class StandardQueryTreeBuilder : QueryTreeBuilder<Query>, IStandardQueryBuilder
     {
         public StandardQueryTreeBuilder()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/TermRangeQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/TermRangeQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/TermRangeQueryNodeBuilder.cs
index 3a58fe4..3ee8e16 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/TermRangeQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/TermRangeQueryNodeBuilder.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link TermRangeQuery} object from a {@link TermRangeQueryNode}
+    /// Builds a <see cref="TermRangeQuery"/> object from a <see cref="TermRangeQueryNode"/>
     /// object.
     /// </summary>
     public class TermRangeQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/WildcardQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/WildcardQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/WildcardQueryNodeBuilder.cs
index aaafeb5..f6ed0b2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/WildcardQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/WildcardQueryNodeBuilder.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
      */
 
     /// <summary>
-    /// Builds a {@link WildcardQuery} object from a {@link WildcardQueryNode}
+    /// Builds a <see cref="WildcardQuery"/> object from a <see cref="WildcardQueryNode"/>
     /// object.
     /// </summary>
     public class WildcardQueryNodeBuilder : IStandardQueryBuilder

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/CommonQueryParserConfiguration.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/CommonQueryParserConfiguration.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/CommonQueryParserConfiguration.cs
index 35ec103..fbf7964 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/CommonQueryParserConfiguration.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/CommonQueryParserConfiguration.cs
@@ -31,39 +31,39 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         /// <summary>
         /// Whether terms of multi-term queries (e.g., wildcard,
         /// prefix, fuzzy and range) should be automatically
-        /// lower-cased or not.  Default is <code>true</code>.
+        /// lower-cased or not.  Default is <c>true</c>.
         /// </summary>
         bool LowercaseExpandedTerms { get; set; }
 
         /// <summary>
-        /// Set to <code>true</code> to allow leading wildcard characters.
-        /// <p>
-        /// When set, <code>*</code> or <code>?</code> are allowed as the first
-        /// character of a PrefixQuery and WildcardQuery. Note that this can produce
+        /// Set to <c>true</c> to allow leading wildcard characters.
+        /// <para/>
+        /// When set, <c>*</c> or <c>?</c> are allowed as the first
+        /// character of a <see cref="PrefixQuery"/> and <see cref="WildcardQuery"/>. Note that this can produce
         /// very slow queries on big indexes.
-        /// <p>
+        /// <para/>
         /// Default: false.
         /// </summary>
         bool AllowLeadingWildcard { get; set; }
 
         /// <summary>
-        /// Set to <code>true</code> to enable position increments in result query.
-        /// <p>
+        /// Set to <c>true</c> to enable position increments in result query.
+        /// <para/>
         /// When set, result phrase and multi-phrase queries will be aware of position
-        /// increments. Useful when e.g. a StopFilter increases the position increment
+        /// increments. Useful when e.g. a <see cref="Analysis.Core.StopFilter"/> increases the position increment
         /// of the token that follows an omitted token.
-        /// <p>
+        /// <para/>
         /// Default: false.
         /// </summary>
         bool EnablePositionIncrements { get; set; }
 
         /// <summary>
         /// By default, it uses 
-        /// {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} when creating a
+        /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/> when creating a
         /// prefix, wildcard and range queries. This implementation is generally
         /// preferable because it a) Runs faster b) Does not have the scarcity of terms
-        /// unduly influence score c) avoids any {@link TooManyListenersException}
-        /// exception. However, if your application really needs to use the
+        /// unduly influence score c) avoids any exception due to too many listeners.
+        /// However, if your application really needs to use the
         /// old-fashioned boolean queries expansion rewriting and the above points are
         /// not relevant then use this change the rewrite method.
         /// </summary>
@@ -98,8 +98,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         float FuzzyMinSim { get; set; }
 
         /// <summary>
-        /// Sets the default <see cref="T:DateTools.Resolution"/> used for certain field when
-        /// no <see cref="T:DateTools.Resolution"/> is defined for this field.
+        /// Sets the default <see cref="DateTools.Resolution"/> used for certain field when
+        /// no <see cref="DateTools.Resolution"/> is defined for this field.
         /// </summary>
         void SetDateResolution(DateTools.Resolution dateResolution);
     }


Mime
View raw message