http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
new file mode 100644
index 0000000..4034dad
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/NamespaceSupport.cs
@@ -0,0 +1,841 @@
+// NamespaceSupport.java - generic Namespace support for SAX.
+// http://www.saxproject.org
+// Written by David Megginson
+// This class is in the Public Domain.  NO WARRANTY!
+// $Id: NamespaceSupport.java,v 1.15 2004/04/26 17:34:35 dmegginson Exp $
+
+using Lucene.Net.Support;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Sax.Helpers
+{
+    /// <summary>
+    /// Encapsulate Namespace logic for use by applications using SAX,
+    /// or internally by SAX drivers.
+    /// <para/>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
+    /// See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// This class encapsulates the logic of Namespace processing: it
+    /// tracks the declarations currently in force for each context and
+    /// automatically processes qualified XML names into their Namespace
+    /// parts; it can also be used in reverse for generating XML qnames
+    /// from Namespaces.
+    /// <para/>
+    /// Namespace support objects are reusable, but the reset method
+    /// must be invoked between each session.
+    /// <para/>Here is a simple session:
+    /// <code>
+    ///     string parts[] = new string[3];
+    ///     NamespaceSupport support = new NamespaceSupport();
+    ///     support.PushContext();
+    ///     support.DeclarePrefix("", "http://www.w3.org/1999/xhtml";);
+    ///     support.DeclarePrefix("dc", "http://www.purl.org/dc#";);
+    ///     parts = support.ProcessName("p", parts, false);
+    ///     Console.WriteLine("Namespace URI: " + parts[0]);
+    ///     Console.WriteLine("Local name: " + parts[1]);
+    ///     Console.WriteLine("Raw name: " + parts[2]);
+    ///     parts = support.ProcessName("dc:title", parts, false);
+    ///     Console.WriteLine("Namespace URI: " + parts[0]);
+    ///     Console.WriteLine("Local name: " + parts[1]);
+    ///     Console.WriteLine("Raw name: " + parts[2]);
+    ///     support.PopContext();
+    /// </code>
+    /// <para/>
+    /// Note that this class is optimized for the use case where most
+    /// elements do not contain Namespace declarations: if the same
+    /// prefix/URI mapping is repeated for each context (for example), this
+    /// class will be somewhat less efficient.
+    /// <para/>
+    /// Although SAX drivers (parsers) may choose to use this class to
+    /// implement namespace handling, they are not required to do so.
+    /// Applications must track namespace information themselves if they
+    /// want to use namespace information.
+    /// </summary>
+    public class NamespaceSupport
+    {
+        /// <summary>
+        /// The XML Namespace URI as a constant.
+        /// The value is <c>http://www.w3.org/XML/1998/namespace</c>
+        /// as defined in the "Namespaces in XML" * recommendation.
+        /// <para>This is the Namespace URI that is automatically mapped to 
the "xml" prefix.</para>
+        /// </summary>
+        public const string XMLNS = "http://www.w3.org/XML/1998/namespace";;
+
+        /// <summary>
+        /// The namespace declaration URI as a constant.
+        /// The value is <c>http://www.w3.org/xmlns/2000/</c>, as defined
+        /// in a backwards-incompatible erratum to the "Namespaces in XML"
+        /// recommendation.  Because that erratum postdated SAX2, SAX2 defaults
+        /// to the original recommendation, and does not normally use this URI.
+        /// <para/>
+        /// This is the Namespace URI that is optionally applied to
+        /// <em>xmlns</em> and <em>xmlns:*</em> attributes, which are used to
+        /// declare namespaces.
+        /// </summary>
+        /// <seealso cref="SetNamespaceDeclUris(bool)" />
+        /// <seealso cref="IsNamespaceDeclUris" />
+        ////
+        public const string NSDECL = "http://www.w3.org/xmlns/2000/";;
+
+
+        ////////////////////////////////////////////////////////////////////
+        // Constructor.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Create a new Namespace support object.
+        /// </summary>
+        public NamespaceSupport()
+        {
+            Reset();
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Context management.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Reset this Namespace support object for reuse.
+        /// <para/>
+        /// It is necessary to invoke this method before reusing the
+        /// Namespace support object for a new session.  If namespace
+        /// declaration URIs are to be supported, that flag must also
+        /// be set to a non-default value.
+        /// </summary>
+        /// <seealso cref="SetNamespaceDeclUris" />
+        public void Reset()
+        {
+            contexts = new Context[32];
+            namespaceDeclUris = false;
+            contextPos = 0;
+            contexts[contextPos] = currentContext = new Context(this);
+            currentContext.DeclarePrefix("xml", XMLNS);
+        }
+
+        /// <summary>
+        /// Start a new Namespace context.
+        /// The new context will automatically inherit
+        /// the declarations of its parent context, but it will also keep
+        /// track of which declarations were made within this context.
+        /// <para/>
+        /// Event callback code should start a new context once per element.
+        /// This means being ready to call this in either of two places.
+        /// For elements that don't include namespace declarations, the
+        /// <see cref="IContentHandler.StartElement(string, string, string, 
IAttributes)"/> callback is the right place.
+        /// For elements with such a declaration, it'd done in the first
+        /// <see cref="IContentHandler.StartPrefixMapping(string, string)"/> 
callback.
+        /// A boolean flag can be used to
+        /// track whether a context has been started yet.  When either of
+        /// those methods is called, it checks the flag to see if a new context
+        /// needs to be started.  If so, it starts the context and sets the
+        /// flag.  After <see cref="IContentHandler.StartElement(string, 
string, string, IAttributes)"/>
+        /// does that, it always clears the flag.
+        /// <para/>
+        /// Normally, SAX drivers would push a new context at the beginning
+        /// of each XML element.  Then they perform a first pass over the
+        /// attributes to process all namespace declarations, making
+        /// <see cref="IContentHandler.StartPrefixMapping(string, string)"/> 
callbacks.
+        /// Then a second pass is made, to determine the namespace-qualified
+        /// names for all attributes and for the element name.
+        /// Finally all the information for the
+        /// <see cref="IContentHandler.StartElement(string, string, string, 
IAttributes)"/> callback is available,
+        /// so it can then be made.
+        /// <para/>
+        /// The Namespace support object always starts with a base context
+        /// already in force: in this context, only the "xml" prefix is
+        /// declared.
+        /// </summary>
+        /// <seealso cref="IContentHandler" />
+        /// <seealso cref="PopContext()" />
+        public void PushContext()
+        {
+            int max = contexts.Length;
+
+            contexts[contextPos].declsOK = false;
+            contextPos++;
+
+            // Extend the array if necessary
+            if (contextPos >= max)
+            {
+                var newContexts = new Context[max * 2];
+                Array.Copy(contexts, 0, newContexts, 0, max);
+                max *= 2;
+                contexts = newContexts;
+            }
+
+            // Allocate the context if necessary.
+            currentContext = contexts[contextPos];
+            if (currentContext == null)
+            {
+                contexts[contextPos] = currentContext = new Context(this);
+            }
+
+            // Set the parent, if any.
+            if (contextPos > 0)
+            {
+                currentContext.SetParent(contexts[contextPos - 1]);
+            }
+        }
+
+        /// <summary>
+        /// Revert to the previous Namespace context.
+        /// <para/>
+        /// Normally, you should pop the context at the end of each
+        /// XML element.  After popping the context, all Namespace prefix
+        /// mappings that were previously in force are restored.
+        /// <para/>
+        /// You must not attempt to declare additional Namespace
+        /// prefixes after popping a context, unless you push another
+        /// context first.
+        /// </summary>
+        /// <seealso cref="PushContext()" />
+        public void PopContext()
+        {
+            contexts[contextPos].Clear();
+            contextPos--;
+            if (contextPos < 0)
+            {
+                throw new InvalidOperationException();
+            }
+            currentContext = contexts[contextPos];
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Operations within a context.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Declare a Namespace prefix.  All prefixes must be declared
+        /// before they are referenced.  For example, a SAX driver (parser)
+        /// would scan an element's attributes
+        /// in two passes:  first for namespace declarations,
+        /// then a second pass using <see cref="ProcessName" /> to
+        /// interpret prefixes against (potentially redefined) prefixes.
+        /// <para/>
+        /// This method declares a prefix in the current Namespace
+        /// context; the prefix will remain in force until this context
+        /// is popped, unless it is shadowed in a descendant context.
+        /// <para/>
+        /// To declare the default element Namespace, use the empty string as
+        /// the prefix.
+        /// <para/>
+        /// Note that you must <em>not</em> declare a prefix after
+        /// you've pushed and popped another Namespace context, or
+        /// treated the declarations phase as complete by processing
+        /// a prefixed name.
+        /// <para/>
+        /// Note that there is an asymmetry in this library: <see 
cref="GetPrefix" /> will not return the "" prefix,
+        /// even if you have declared a default element namespace.
+        /// To check for a default namespace,
+        /// you have to look it up explicitly using <see cref="GetUri" />.
+        /// This asymmetry exists to make it easier to look up prefixes
+        /// for attribute names, where the default prefix is not allowed.
+        /// </summary>
+        /// <param name="prefix">
+        /// The prefix to declare, or the empty string to
+        /// indicate the default element namespace.  This may never have
+        /// the value "xml" or "xmlns".
+        /// </param>
+        /// <param name="uri">
+        /// The Namespace URI to associate with the prefix.
+        /// </param>
+        /// <returns><c>true</c> if the prefix was legal, <c>false</c> 
otherwise</returns>
+        /// <seealso cref="ProcessName(string, string[], bool)" />
+        /// <seealso cref="GetUri(string)" />
+        /// <seealso cref="GetPrefix(string)" />
+        public bool DeclarePrefix(string prefix, string uri)
+        {
+            if (prefix.Equals("xml") || prefix.Equals("xmlns"))
+            {
+                return false;
+            }
+            currentContext.DeclarePrefix(prefix, uri);
+            return true;
+        }
+
+        /// <summary>
+        /// Process a raw XML qualified name, after all declarations in the
+        /// current context have been handled by <see cref="DeclarePrefix" />.
+        /// <para>
+        /// This method processes a raw XML qualified name in the
+        /// current context by removing the prefix and looking it up among
+        /// the prefixes currently declared.  The return value will be the
+        /// array supplied by the caller, filled in as follows:
+        /// </para>
+        /// <list type="table">
+        ///     <item>
+        ///         <term>parts[0]</term>
+        ///         <description>The Namespace URI, or an empty string if none 
is in use.</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>parts[1]</term>
+        ///         <description>The local name (without prefix).</description>
+        ///     </item>
+        ///     <item>
+        ///         <term>parts[2]</term>
+        ///         <description>The original raw name.</description>
+        ///     </item>
+        /// </list>
+        /// <para>
+        /// All of the strings in the array will be internalized.  If
+        /// the raw name has a prefix that has not been declared, then
+        /// the return value will be null.
+        /// </para>
+        /// <para>
+        /// Note that attribute names are processed differently than
+        /// element names: an unprefixed element name will receive the
+        /// default Namespace (if any), while an unprefixed attribute name
+        /// will not.
+        /// </para>
+        /// </summary>
+        /// <param name="qName">
+        /// The XML qualified name to be processed.
+        /// </param>
+        /// <param name="parts">
+        /// An array supplied by the caller, capable of
+        /// holding at least three members.
+        /// </param>
+        /// <param name="isAttribute">
+        /// A flag indicating whether this is an
+        /// attribute name (true) or an element name (false).
+        /// </param>
+        /// <returns>
+        /// The supplied array holding three internalized strings
+        /// representing the Namespace URI (or empty string), the
+        /// local name, and the XML qualified name; or null if there
+        /// is an undeclared prefix.
+        /// </returns>
+        /// <seealso cref="DeclarePrefix" />
+        /// <seealso cref="string.Intern(string)" />
+        public string[] ProcessName(string qName, string[] parts, bool 
isAttribute)
+        {
+            string[] myParts = currentContext.ProcessName(qName, isAttribute);
+            if (myParts == null)
+            {
+                return null;
+            }
+            parts[0] = myParts[0];
+            parts[1] = myParts[1];
+            parts[2] = myParts[2];
+            return parts;
+        }
+
+        /// <summary>
+        /// Look up a prefix and get the currently-mapped Namespace URI.
+        /// <para>
+        /// This method looks up the prefix in the current context.
+        /// Use the empty string ("") for the default Namespace.
+        /// </para>
+        /// </summary>
+        /// <param name="prefix">
+        /// The prefix to look up.
+        /// </param>
+        /// <returns>
+        /// The associated Namespace URI, or null if the prefix
+        /// is undeclared in this context.
+        /// </returns>
+        /// <seealso cref="GetPrefix" />
+        /// <seealso cref="GetPrefixes()" />
+        public string GetUri(string prefix)
+        {
+            return currentContext.GetURI(prefix);
+        }
+
+        /// <summary>
+        /// Return an enumeration of all prefixes whose declarations are
+        /// active in the current context.
+        /// This includes declarations from parent contexts that have
+        /// not been overridden.
+        /// <para>
+        /// <strong>Note:</strong> if there is a default prefix, it will not be
+        /// returned in this enumeration; check for the default prefix
+        /// using the <see cref="GetUri" /> with an argument of "".
+        /// </para>
+        /// </summary>
+        /// <returns>An enumeration of prefixes (never empty).</returns>
+        /// <seealso cref="GetDeclaredPrefixes" />
+        /// <seealso cref="GetUri" />
+        public IEnumerable GetPrefixes()
+        {
+            return currentContext.GetPrefixes();
+        }
+
+        /// <summary>
+        /// Return one of the prefixes mapped to a Namespace URI.
+        /// <para>
+        /// If more than one prefix is currently mapped to the same
+        /// URI, this method will make an arbitrary selection; if you
+        /// want all of the prefixes, use the <see cref="GetPrefixes()" />
+        /// method instead.
+        /// </para>
+        /// <para>
+        /// <strong>Note:</strong> this will never return the empty (default) 
prefix;
+        /// to check for a default prefix, use the <see cref="GetUri" />
+        /// method with an argument of "".
+        /// </para>
+        /// </summary>
+        /// <param name="uri">
+        /// the namespace URI
+        /// </param>
+        /// <returns>
+        /// one of the prefixes currently mapped to the URI supplied,
+        /// or null if none is mapped or if the URI is assigned to
+        /// the default namespace
+        /// </returns>
+        /// <seealso cref="GetPrefixes(string)" />
+        /// <seealso cref="GetUri" />
+        public string GetPrefix(string uri)
+        {
+            return currentContext.GetPrefix(uri);
+        }
+
+        /// <summary>
+        /// Return an enumeration of all prefixes for a given URI whose
+        /// declarations are active in the current context.
+        /// This includes declarations from parent contexts that have
+        /// not been overridden.
+        /// <para>
+        /// This method returns prefixes mapped to a specific Namespace
+        /// URI.  The xml: prefix will be included.  If you want only one
+        /// prefix that's mapped to the Namespace URI, and you don't care
+        /// which one you get, use the <see cref="GetPrefix" />
+        /// method instead.
+        /// </para>
+        /// <para>
+        /// <strong>Note:</strong> the empty (default) prefix is 
<em>never</em> included
+        /// in this enumeration; to check for the presence of a default
+        /// Namespace, use the <see cref="GetUri" /> method with an
+        /// argument of "".
+        /// </para>
+        /// </summary>
+        /// <param name="uri">
+        /// The Namespace URI.
+        /// </param>
+        /// <returns>An enumeration of prefixes (never empty).</returns>
+        /// <seealso cref="GetPrefix" />
+        /// <seealso cref="GetDeclaredPrefixes" />
+        /// <seealso cref="GetUri" />
+        public IEnumerable GetPrefixes(string uri)
+        {
+            var prefixes = new ArrayList();
+            IEnumerator allPrefixes = GetPrefixes().GetEnumerator();
+            while (allPrefixes.MoveNext())
+            {
+                var prefix = (string)allPrefixes.Current;
+                if (uri.Equals(GetUri(prefix)))
+                {
+                    prefixes.Add(prefix);
+                }
+            }
+            return prefixes;
+        }
+
+        /// <summary>
+        /// Return an enumeration of all prefixes declared in this context.
+        /// <para>
+        /// The empty (default) prefix will be included in this
+        /// enumeration; note that this behaviour differs from that of
+        /// <see cref="GetPrefix" /> and <see cref="GetPrefixes()" />.
+        /// </para>
+        /// </summary>
+        /// <returns>
+        /// An enumeration of all prefixes declared in this
+        /// context.
+        /// </returns>
+        /// <seealso cref="GetPrefixes()" />
+        /// <seealso cref="GetUri" />
+        public IEnumerable GetDeclaredPrefixes()
+        {
+            return currentContext.GetDeclaredPrefixes();
+        }
+
+        /// <summary>
+        /// Controls whether namespace declaration attributes are placed
+        /// into the <see cref="NSDECL" /> namespace
+        /// by <see cref="ProcessName" />.  This may only be
+        /// changed before any contexts have been pushed.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// when attempting to set this
+        /// after any context has been pushed.
+        /// </exception>
+        public void SetNamespaceDeclUris(bool value)
+        {
+            if (contextPos != 0)
+            {
+                throw new InvalidOperationException();
+            }
+            if (value == namespaceDeclUris)
+            {
+                return;
+            }
+            namespaceDeclUris = value;
+            if (value)
+            {
+                currentContext.DeclarePrefix("xmlns", NSDECL);
+            }
+            else
+            {
+                contexts[contextPos] = currentContext = new Context(this);
+                currentContext.DeclarePrefix("xml", XMLNS);
+            }
+        }
+
+        /// <summary>
+        /// Returns true if namespace declaration attributes are placed into
+        /// a namespace.  This behavior is not the default.
+        /// </summary>
+        public bool IsNamespaceDeclUris
+        {
+            get { return namespaceDeclUris; }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Internal state.
+        ////////////////////////////////////////////////////////////////////
+        
+        private Context[] contexts;
+        private Context currentContext;
+        private int contextPos;
+        private bool namespaceDeclUris;
+
+        ////////////////////////////////////////////////////////////////////
+        // Internal classes.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Internal class for a single Namespace context.
+        /// </summary>
+        /// <remarks>
+        /// This module caches and reuses Namespace contexts,
+        /// so the number allocated
+        /// will be equal to the element depth of the document, not to the 
total
+        /// number of elements (i.e. 5-10 rather than tens of thousands).
+        /// Also, data structures used to represent contexts are shared when
+        /// possible (child contexts without declarations) to further reduce
+        /// the amount of memory that's consumed.
+        /// </remarks>
+        internal sealed class Context
+        {
+            private readonly NamespaceSupport outerInstance;
+
+            /// <summary>
+            /// Create the root-level Namespace context.
+            /// </summary>
+            public Context(NamespaceSupport outerInstance)
+            {
+                this.outerInstance = outerInstance;
+                CopyTables();
+            }
+
+            /// <summary>
+            /// (Re)set the parent of this Namespace context.
+            /// The context must either have been freshly constructed,
+            /// or must have been cleared.
+            /// </summary>
+            /// <param name="parent">The parent Namespace context 
object.</param>
+            public void SetParent(Context parent)
+            {
+                this.parent = parent;
+                declarations = null;
+                prefixTable = parent.prefixTable;
+                uriTable = parent.uriTable;
+                elementNameTable = parent.elementNameTable;
+                attributeNameTable = parent.attributeNameTable;
+                defaultNs = parent.defaultNs;
+                declSeen = false;
+                declsOK = true;
+            }
+
+            /// <summary>
+            /// Makes associated state become collectible,
+            /// invalidating this context.
+            /// <see cref="SetParent(Context)"/> must be called before
+            /// this context may be used again.
+            /// </summary>
+            public void Clear()
+            {
+                parent = null;
+                prefixTable = null;
+                uriTable = null;
+                elementNameTable = null;
+                attributeNameTable = null;
+                defaultNs = null;
+            }
+
+            /// <summary>
+            /// Declare a Namespace prefix for this context.
+            /// </summary>
+            /// <param name="prefix">The prefix to declare.</param>
+            /// <param name="uri">The associated Namespace URI.</param>
+            /// <seealso cref="DeclarePrefix(string, string)"/>
+            public void DeclarePrefix(string prefix, string uri)
+            {
+                // Lazy processing...
+                if (!declsOK)
+                {
+                    throw new InvalidOperationException("can't declare any 
more prefixes in this context");
+                }
+                if (!declSeen)
+                {
+                    CopyTables();
+                }
+                if (declarations == null)
+                {
+                    declarations = new List<string>();
+                }
+
+                prefix = prefix.Intern();
+                uri = uri.Intern();
+                if ("".Equals(prefix))
+                {
+                    if ("".Equals(uri))
+                    {
+                        defaultNs = null;
+                    }
+                    else
+                    {
+                        defaultNs = uri;
+                    }
+                }
+                else
+                {
+                    prefixTable.Add(prefix, uri);
+                    uriTable.Add(uri, prefix); // may wipe out another prefix
+                }
+                declarations.Add(prefix);
+            }
+
+            /// <summary>
+            /// Process an XML qualified name in this context.
+            /// </summary>
+            /// <param name="qName">The XML qualified name.</param>
+            /// <param name="isAttribute">true if this is an attribute 
name.</param>
+            /// <param name="namespaceDeclUris"></param>
+            /// <returns>An array of three strings containing the
+            /// URI part (or empty string), the local part,
+            /// and the raw name, all internalized, or null
+            /// if there is an undeclared prefix.</returns>
+            /// <seealso cref="NamespaceSupport.ProcessName(string, bool)"/>
+            internal string[] ProcessName(string qName, bool isAttribute)
+            {
+                string[] name;
+                IDictionary<string, string[]> table;
+
+                // detect errors in call sequence
+                declsOK = false;
+
+                // Select the appropriate table.
+                if (isAttribute)
+                {
+                    table = attributeNameTable;
+                }
+                else
+                {
+                    table = elementNameTable;
+                }
+
+                // Start by looking in the cache, and
+                // return immediately if the name
+                // is already known in this content
+                if (table.ContainsKey(qName))
+                {
+                    return (string[])table[qName];
+                }
+
+                // We haven't seen this name in this
+                // context before.  Maybe in the parent
+                // context, but we can't assume prefix
+                // bindings are the same.
+                name = new string[3];
+                name[2] = qName.Intern();
+                int index = qName.IndexOf(':');
+
+                // No prefix.
+                if (index == -1)
+                {
+                    if (isAttribute)
+                    {
+                        if (qName == "xmlns" && 
outerInstance.namespaceDeclUris)
+                        {
+                            name[0] = NSDECL;
+                        }
+                        else
+                        {
+                            name[0] = "";
+                        }
+                    }
+                    else if (defaultNs == null)
+                    {
+                        name[0] = "";
+                    }
+                    else
+                    {
+                        name[0] = defaultNs;
+                    }
+                    name[1] = name[2];
+                }
+
+                // Prefix
+                else
+                {
+                    string prefix = qName.Substring(0, index);
+                    string local = qName.Substring(index + 1);
+                    string uri = null;
+                    if ("".Equals(prefix))
+                    {
+                        uri = defaultNs;
+                    }
+                    else if (prefixTable.ContainsKey(prefix))
+                    {
+                        uri = (string)prefixTable[prefix];
+                    }
+                    if (uri == null || (!isAttribute && 
"xmlns".Equals(prefix)))
+                    {
+                        return null;
+                    }
+                    name[0] = uri;
+                    name[1] = local.Intern();
+                }
+
+                // Save in the cache for future use.
+                // (Could be shared with parent context...)
+                table.Add(name[2], name);
+                return name;
+            }
+
+            /// <summary>
+            /// Look up the URI associated with a prefix in this context.
+            /// </summary>
+            /// <param name="prefix">The prefix to look up.</param>
+            /// <returns>The associated Namespace URI, or null if none is 
declared.</returns>
+            /// <seealso cref="NamespaceSupport.GetUri(string)"/>
+            internal string GetURI(string prefix)
+            {
+                if ("".Equals(prefix))
+                {
+                    return defaultNs;
+                }
+                if (prefixTable == null)
+                {
+                    return null;
+                }
+                if (prefixTable.ContainsKey(prefix))
+                {
+                    return (string)prefixTable[prefix];
+                }
+                return null;
+            }
+
+            /// <summary>
+            /// Look up one of the prefixes associated with a URI in this 
context.
+            /// <para/>
+            /// Since many prefixes may be mapped to the same URI, the return 
value may be unreliable.
+            /// </summary>
+            /// <param name="uri">The URI to look up.</param>
+            /// <returns>The associated prefix, or null if none is 
declared.</returns>
+            /// <seealso cref="NamespaceSupport.GetPrefix(string)"/>
+            internal string GetPrefix(string uri)
+            {
+                if (uriTable == null)
+                {
+                    return null;
+                }
+                if (uriTable.ContainsKey(uri))
+                {
+                    return (string)uriTable[uri];
+                }
+                return null;
+            }
+
+            /// <summary>
+            /// Return an enumeration of prefixes declared in this context.
+            /// </summary>
+            /// <returns>An enumeration of prefixes (possibly empty).</returns>
+            /// <seealso cref="NamespaceSupport.GetDeclaredPrefixes()"/>
+            internal IEnumerable GetDeclaredPrefixes()
+            {
+                if (declarations == null)
+                {
+                    return Enumerable.Empty<object>();
+                }
+                return declarations;
+            }
+
+            /// <summary>
+            /// Return an enumeration of all prefixes currently in force.
+            /// <para/>
+            /// The default prefix, if in force, is <em>not</em>
+            /// returned, and will have to be checked for separately.
+            /// </summary>
+            /// <returns>An enumeration of prefixes (never empty).</returns>
+            /// <seealso cref="NamespaceSupport.GetPrefixes()"/>
+            internal IEnumerable GetPrefixes()
+            {
+                if (prefixTable == null)
+                {
+                    return Enumerable.Empty<object>();
+                }
+                return prefixTable.Keys;
+            }
+
+            ////////////////////////////////////////////////////////////////
+            // Internal methods.
+            ////////////////////////////////////////////////////////////////
+
+            /// <summary>
+            /// Copy on write for the internal tables in this context.
+            /// <para/>
+            /// This class is optimized for the normal case where most
+            /// elements do not contain Namespace declarations.
+            /// </summary>
+            private void CopyTables()
+            {
+                if (prefixTable != null)
+                {
+                    prefixTable = (Hashtable)prefixTable.Clone();
+                }
+                else
+                {
+                    prefixTable = new Hashtable();
+                }
+                if (uriTable != null)
+                {
+                    uriTable = (Hashtable)uriTable.Clone();
+                }
+                else
+                {
+                    uriTable = new Hashtable();
+                }
+                elementNameTable = new Dictionary<string, string[]>();
+                attributeNameTable = new Dictionary<string, string[]>();
+                declSeen = true;
+            }
+
+            ////////////////////////////////////////////////////////////////
+            // Protected state.
+            ////////////////////////////////////////////////////////////////
+
+            private Hashtable prefixTable;
+            private Hashtable uriTable;
+            private IDictionary<string, string[]> elementNameTable;
+            private IDictionary<string, string[]> attributeNameTable;
+            private string defaultNs;
+            internal bool declsOK = true;
+
+            ////////////////////////////////////////////////////////////////
+            // Internal state.
+            ////////////////////////////////////////////////////////////////
+
+            private IList<string> declarations;
+            private bool declSeen;
+            private Context parent;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/Helpers/XMLFilterImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/Helpers/XMLFilterImpl.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/XMLFilterImpl.cs
new file mode 100644
index 0000000..cbf9e6d
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/Helpers/XMLFilterImpl.cs
@@ -0,0 +1,587 @@
+// XMLFilterImpl.java - base SAX2 filter implementation.
+// http://www.saxproject.org
+// Written by David Megginson
+// NO WARRANTY!  This class is in the Public Domain.
+// $Id: XMLFilterImpl.java,v 1.9 2004/04/26 17:34:35 dmegginson Exp $
+
+using System;
+
+namespace Sax.Helpers
+{
+    /// <summary>
+    /// Base class for deriving an XML filter.
+    /// <para/>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
+    /// See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// This class is designed to sit between an <see cref="IXMLReader" />
+    /// and the client application's event handlers.  By default, it
+    /// does nothing but pass requests up to the reader and events
+    /// on to the handlers unmodified, but subclasses can override
+    /// specific methods to modify the event stream or the configuration
+    /// requests as they pass through.
+    /// </summary>
+    /// <seealso cref="IXMLFilter" />
+    /// <seealso cref="IXMLReader" />
+    /// <seealso cref="IEntityResolver" />
+    /// <seealso cref="IDTDHandler" />
+    /// <seealso cref="IContentHandler" />
+    /// <seealso cref="IErrorHandler" />
+    public class XMLFilter : IXMLFilter, IEntityResolver, IDTDHandler, 
IContentHandler, IErrorHandler
+    {
+        /// <summary>
+        /// Construct an empty XML filter, with no parent.
+        /// <para>
+        /// This filter will have no parent: you must assign a parent
+        /// before you start a parse or do any configuration with
+        /// setFeature or setProperty, unless you use this as a pure event
+        /// consumer rather than as an <see cref="IXmlReader" />.
+        /// </para>
+        /// </summary>
+        /// <seealso cref="IXMLReader.SetFeature" />
+        /// <seealso cref="IXMLReader.SetProperty" />
+        /// <seealso cref="Parent" />
+        public XMLFilter()
+        {
+        }
+
+        /// <summary>
+        /// Construct an XML filter with the specified parent.
+        /// </summary>
+        /// <param name="parent">The parent</param>
+        /// <seealso cref="Parent" />
+        public XMLFilter(IXMLReader parent)
+        {
+            this.parent = parent;
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IXMLFilter.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Gets or sets the parent reader.
+        /// </summary>
+        /// <remarks>
+        /// This is the <see cref="IXMLReader"/> from which 
+        /// this filter will obtain its events and to which it will pass its 
+        /// configuration requests.  The parent may itself be another filter.
+        /// <para/>
+        /// If there is no parent reader set, any attempt to parse
+        /// or to set or get a feature or property will fail.
+        /// </remarks>
+        public IXMLReader Parent
+        {
+            get { return parent; }
+            set { parent = value; }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IXMLReader.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Set the value of a feature.
+        /// <para/>
+        /// This will always fail if the parent is null.
+        /// </summary>
+        /// <param name="name">The feature name.</param>
+        /// <param name="value">The requested feature value.</param>
+        /// <exception cref="SAXNotRecognizedException">If the feature
+        /// value can't be assigned or retrieved from the parent.</exception>
+        /// <exception cref="SAXNotSupportedException">When the
+        /// parent recognizes the feature name but
+        /// cannot set the requested value.</exception>
+        public virtual void SetFeature(string name, bool value)
+        {
+            if (parent != null)
+            {
+                parent.SetFeature(name, value);
+            }
+            else
+            {
+                throw new SAXNotRecognizedException("Feature: " + name);
+            }
+        }
+
+        /// <summary>
+        /// Look up the value of a feature.
+        /// <para/>
+        /// This will always fail if the parent is null.
+        /// </summary>
+        /// <param name="name">The feature name.</param>
+        /// <returns>The current value of the feature.</returns>
+        /// <exception cref="SAXNotRecognizedException">If the feature
+        /// value can't be assigned or retrieved from the parent.</exception>
+        /// <exception cref="SAXNotSupportedException">When the
+        /// parent recognizes the feature name but
+        /// cannot determine its value at this time.</exception>
+        public virtual bool GetFeature(string name)
+        {
+            if (parent != null)
+            {
+                return parent.GetFeature(name);
+            }
+            throw new SAXNotRecognizedException("Feature: " + name);
+        }
+
+        /// <summary>
+        /// Set the value of a property.
+        /// <para/>
+        /// This will always fail if the parent is null.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="value">The requested property value.</param>
+        /// <exception cref="SAXNotRecognizedException">If the property
+        /// value can't be assigned or retrieved from the parent.</exception>
+        /// <exception cref="SAXNotSupportedException">When the
+        /// parent recognizes the property name but
+        /// cannot set the requested value.</exception>
+        public virtual void SetProperty(string name, object value)
+        {
+            if (parent != null)
+            {
+                parent.SetProperty(name, value);
+            }
+            else
+            {
+                throw new SAXNotRecognizedException("Property: " + name);
+            }
+        }
+
+        /// <summary>
+        /// Look up the value of a property.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <returns>The current value of the property.</returns>
+        /// <exception cref="SAXNotRecognizedException">If the property
+        /// value can't be assigned or retrieved from the parent.</exception>
+        /// <exception cref="SAXNotSupportedException">When the
+        /// parent recognizes the property name but
+        /// cannot determine its value at this time.</exception>
+        public virtual object GetProperty(string name)
+        {
+            if (parent != null)
+            {
+                return parent.GetProperty(name);
+            }
+            throw new SAXNotRecognizedException("Property: " + name);
+        }
+
+        /// <summary>
+        /// Gets or Sets the entity resolver.
+        /// </summary>
+        public IEntityResolver EntityResolver
+        {
+            get { return entityResolver; }
+            set { entityResolver = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the DTD event handler.
+        /// </summary>
+        public IDTDHandler DTDHandler
+        {
+            get { return dtdHandler; }
+            set { dtdHandler = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the content event handler.
+        /// </summary>
+        public IContentHandler ContentHandler
+        {
+            get { return contentHandler; }
+            set { contentHandler = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the error event handler.
+        /// </summary>
+        public IErrorHandler ErrorHandler
+        {
+            get { return errorHandler; }
+            set { errorHandler = value; }
+        }
+
+        /// <summary>
+        /// Parse an XML document.
+        /// <para>
+        /// The application can use this method to instruct the XML
+        /// reader to begin parsing an XML document from any valid input
+        /// source (a character stream, a byte stream, or a URI).
+        /// </para>
+        /// <para>
+        /// Applications may not invoke this method while a parse is in
+        /// progress (they should create a new XMLReader instead for each
+        /// nested XML document).  Once a parse is complete, an
+        /// application may reuse the same XMLReader object, possibly with a
+        /// different input source.
+        /// Configuration of the XMLReader object (such as handler bindings and
+        /// values established for feature flags and properties) is unchanged
+        /// by completion of a parse, unless the definition of that aspect of
+        /// the configuration explicitly specifies other behavior.
+        /// (For example, feature flags or properties exposing
+        /// characteristics of the document being parsed.)
+        /// </para>
+        /// <para>
+        /// During the parse, the XMLReader will provide information
+        /// about the XML document through the registered event
+        /// handlers.
+        /// </para>
+        /// <para>
+        /// This method is synchronous: it will not return until parsing
+        /// has ended.  If a client application wants to terminate
+        /// parsing early, it should throw an exception.
+        /// </para>
+        /// </summary>
+        /// <param name="input">
+        /// The input source for the top-level of the
+        /// XML document.
+        /// </param>
+        /// <exception cref="SAXException">
+        /// Any SAX exception, possibly
+        /// wrapping another exception.
+        /// </exception>
+        /// <exception cref="System.IO.IOException">
+        /// An IO exception from the parser,
+        /// possibly from a byte stream or character stream
+        /// supplied by the application.
+        /// </exception>
+        /// <seealso cref="InputSource" />
+        /// <seealso cref="Parse(string)" />
+        /// <seealso cref="IEntityResolver" />
+        /// <seealso cref="IDTDHandler" />
+        /// <seealso cref="IContentHandler" />
+        /// <seealso cref="IErrorHandler" />
+        public virtual void Parse(InputSource input)
+        {
+            SetupParse();
+            parent.Parse(input);
+        }
+
+        /// <summary>
+        /// Parse a document.
+        /// </summary>
+        /// <param name="systemId">The system identifier as a fully-qualified 
URI.</param>
+        /// <exception cref="SAXException">Any SAX exception, possibly
+        /// wrapping another exception.</exception>
+        /// <exception cref="System.IO.IOException">An IO exception from the 
parser,
+        /// possibly from a byte stream or character stream
+        /// supplied by the application.</exception>
+        public virtual void Parse(string systemId)
+        {
+            Parse(new InputSource(systemId));
+        }
+
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IEntityResolver.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Filter an external entity resolution.
+        /// </summary>
+        /// <param name="publicId">The entity's public identifier, or 
null.</param>
+        /// <param name="systemId">The entity's system identifier.</param>
+        /// <returns>A new <see cref="InputSource"/> or null for the 
default.</returns>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        /// <exception cref="System.IO.IOException">The client may throw an
+        /// I/O-related exception while obtaining the
+        /// new <see cref="InputSource"/>.</exception>
+        public virtual InputSource ResolveEntity(string publicId, string 
systemId)
+        {
+            if (entityResolver != null)
+            {
+                return entityResolver.ResolveEntity(publicId, systemId);
+            }
+            return null;
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IDTDHandler.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Filter a notation declaration event.
+        /// </summary>
+        /// <param name="name">The notation name.</param>
+        /// <param name="publicId">The notation's public identifier, or 
null.</param>
+        /// <param name="systemId">The notation's system identifier, or 
null.</param>
+        /// <seealso cref="SAXException">The client may throw
+        /// an exception during processing.</seealso>
+        public virtual void NotationDecl(string name, string publicId, string 
systemId)
+        {
+            if (dtdHandler != null)
+            {
+                dtdHandler.NotationDecl(name, publicId, systemId);
+            }
+        }
+
+        /// <summary>
+        /// Filter an unparsed entity declaration event.
+        /// </summary>
+        /// <param name="name">The entity name.</param>
+        /// <param name="publicId">The entity's public identifier, or 
null.</param>
+        /// <param name="systemId">The entity's system identifier, or 
null.</param>
+        /// <param name="notationName">The name of the associated 
notation.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void UnparsedEntityDecl(string name, string publicId, 
string systemId, string notationName)
+        {
+            if (dtdHandler != null)
+            {
+                dtdHandler.UnparsedEntityDecl(name, publicId, systemId, 
notationName);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IContentHandler.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Filter a new document locator event.
+        /// </summary>
+        /// <param name="locator">The document locator.</param>
+        public virtual void SetDocumentLocator(ILocator locator)
+        {
+            this.locator = locator;
+            if (contentHandler != null)
+            {
+                contentHandler.SetDocumentLocator(locator);
+            }
+        }
+
+        /// <summary>
+        /// Filter a start document event.
+        /// </summary>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void StartDocument()
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.StartDocument();
+            }
+        }
+
+        /// <summary>
+        /// Filter an end document event.
+        /// </summary>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void EndDocument()
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.EndDocument();
+            }
+        }
+
+        /// <summary>
+        /// Filter a start Namespace prefix mapping event.
+        /// </summary>
+        /// <param name="prefix">The Namespace prefix.</param>
+        /// <param name="uri">The Namespace URI.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void StartPrefixMapping(string prefix, string uri)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.StartPrefixMapping(prefix, uri);
+            }
+        }
+
+        /// <summary>
+        /// Filter an end Namespace prefix mapping event.
+        /// </summary>
+        /// <param name="prefix">The Namespace prefix.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void EndPrefixMapping(string prefix)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.EndPrefixMapping(prefix);
+            }
+        }
+
+        /// <summary>
+        /// Filter a start element event.
+        /// </summary>
+        /// <param name="uri">The element's Namespace URI, or the empty 
string.</param>
+        /// <param name="localName">The element's local name, or the empty 
string.</param>
+        /// <param name="qName">The element's qualified (prefixed) name, or 
the empty string.</param>
+        /// <param name="atts">The element's attributes.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void StartElement(string uri, string localName, string 
qName, IAttributes atts)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.StartElement(uri, localName, qName, atts);
+            }
+        }
+
+        /// <summary>
+        /// Filter an end element event.
+        /// </summary>
+        /// <param name="uri">The element's Namespace URI, or the empty 
string.</param>
+        /// <param name="localName">The element's local name, or the empty 
string.</param>
+        /// <param name="qName">The element's qualified (prefixed) name, or 
the empty string.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void EndElement(string uri, string localName, string 
qName)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.EndElement(uri, localName, qName);
+            }
+        }
+
+        /// <summary>
+        /// Filter a character data event.
+        /// </summary>
+        /// <param name="ch">An array of characters.</param>
+        /// <param name="start">The starting position in the array.</param>
+        /// <param name="length">The number of characters to use from the 
array.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void Characters(char[] ch, int start, int length)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.Characters(ch, start, length);
+            }
+        }
+
+        /// <summary>
+        /// Filter an ignorable whitespace event.
+        /// </summary>
+        /// <param name="ch">An array of characters.</param>
+        /// <param name="start">The starting position in the array.</param>
+        /// <param name="length">The number of characters to use from the 
array.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void IgnorableWhitespace(char[] ch, int start, int 
length)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.IgnorableWhitespace(ch, start, length);
+            }
+        }
+
+        /// <summary>
+        /// Filter a processing instruction event.
+        /// </summary>
+        /// <param name="target">The processing instruction target.</param>
+        /// <param name="data">The text following the target.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void ProcessingInstruction(string target, string data)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.ProcessingInstruction(target, data);
+            }
+        }
+
+        /// <summary>
+        /// Filter a skipped entity event.
+        /// </summary>
+        /// <param name="name">The name of the skipped entity.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void SkippedEntity(string name)
+        {
+            if (contentHandler != null)
+            {
+                contentHandler.SkippedEntity(name);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Implementation of IErrorHandler.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Filter a warning event.
+        /// </summary>
+        /// <param name="e">The warning as an exception.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void Warning(SAXParseException e)
+        {
+            if (errorHandler != null)
+            {
+                errorHandler.Warning(e);
+            }
+        }
+
+        /// <summary>
+        /// Filter an error event.
+        /// </summary>
+        /// <param name="e">The error as an exception.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void Error(SAXParseException e)
+        {
+            if (errorHandler != null)
+            {
+                errorHandler.Error(e);
+            }
+        }
+
+        /// <summary>
+        /// Filter a fatal error event.
+        /// </summary>
+        /// <param name="e">The error as an exception.</param>
+        /// <exception cref="SAXException">The client may throw
+        /// an exception during processing.</exception>
+        public virtual void FatalError(SAXParseException e)
+        {
+            if (errorHandler != null)
+            {
+                errorHandler.FatalError(e);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Internal methods.
+        ////////////////////////////////////////////////////////////////////
+
+        /// <summary>
+        /// Set up before a parse.
+        /// <para/>
+        /// Before every parse, check whether the parent is
+        /// non-null, and re-register the filter for all of the
+        /// events.
+        /// </summary>
+        private void SetupParse()
+        {
+            if (parent == null)
+            {
+                throw new InvalidOperationException("No parent for filter");
+            }
+            parent.EntityResolver = this;
+            parent.DTDHandler = this;
+            parent.ContentHandler = this;
+            parent.ErrorHandler = this;
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Internal state.
+        ////////////////////////////////////////////////////////////////////
+
+        private IXMLReader parent = null;
+        private ILocator locator = null;
+        private IEntityResolver entityResolver = null;
+        private IDTDHandler dtdHandler = null;
+        private IContentHandler contentHandler = null;
+        private IErrorHandler errorHandler = null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/InputSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/InputSource.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/InputSource.cs
new file mode 100644
index 0000000..00b3490
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/InputSource.cs
@@ -0,0 +1,242 @@
+// SAX input source.
+// http://www.saxproject.org
+// No warranty; no copyright -- use this as you will.
+// $Id: InputSource.java,v 1.10 2004/12/02 02:49:58 dmegginson Exp $
+
+using System.IO;
+using System.Text;
+
+namespace Sax
+{
+    /// <summary>
+    /// A single input source for an XML entity.
+    /// </summary>
+    /// <remarks>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em>
+    /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// This class allows a SAX application to encapsulate information
+    /// about an input source in a single object, which may include
+    /// a public identifier, a system identifier, a byte stream (possibly
+    /// with a specified encoding), and/or a character stream.
+    /// <para/>
+    /// There are two places that the application can deliver an
+    /// input source to the parser: as the argument to the <see 
cref="IParser.Parse(InputSource)"/>
+    /// method, or as the return value of the <see 
cref="IEntityResolver.ResolveEntity(string, string)"/>
+    /// method.
+    /// <para/>
+    /// The SAX parser will use the InputSource object to determine how
+    /// to read XML input. If there is a character stream available, the
+    /// parser will read that stream directly, disregarding any text
+    /// encoding declaration found in that stream.
+    /// If there is no character stream, but there is
+    /// a byte stream, the parser will use that byte stream, using the
+    /// encoding specified in the <see cref="InputSource"/> or else (if no 
encoding is
+    /// specified) autodetecting the character encoding using an algorithm
+    /// such as the one in the XML specification. If neither a character
+    /// stream nor a
+    /// byte stream is available, the parser will attempt to open a URL
+    /// connection to the resource identified by the system
+    /// identifier.
+    /// <para/>
+    /// An <see cref="InputSource"/> object belongs to the application: the 
SAX parser
+    /// shall never modify it in any way (it may modify a copy if 
+    /// necessary).  However, standard processing of both byte and
+    /// character streams is to close them on as part of end-of-parse cleanup,
+    /// so applications should not attempt to re-use such streams after they
+    /// have been handed to a parser.
+    /// </remarks>
+    /// <since>SAX 1.0</since>
+    /// <author>David Megginson</author>
+    /// <version>2.0.1 (sax2r2)</version>
+    /// <seealso cref="IXMLReader.Parse(InputSource)"/>
+    /// <seealso cref="IEntityResolver.ResolveEntity(string, string)"/>
+    /// <seealso cref="System.IO.Stream"/>
+    /// <seealso cref="System.IO.TextReader"/>
+    public class InputSource
+    {
+        /// <summary>
+        /// Zero-argument default constructor.
+        /// </summary>
+        /// <seealso cref="PublicId"/>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="Stream"/>
+        /// <seealso cref="TextReader"/>
+        /// <seealso cref="Encoding"/>
+        public InputSource()
+        {
+        }
+
+        /// <summary>
+        /// Create a new input source with a system identifier.
+        /// </summary>
+        /// <remarks>
+        /// Applications may use <see cref="PublicId"/> to include a 
+        /// public identifier as well, or <see cref="Encoding"/> to specify
+        /// the character encoding, if known.
+        /// <para/>
+        /// If the system identifier is a URL, it must be fully
+        /// resolved (it may not be a relative URL).
+        /// </remarks>
+        /// <param name="systemId">The system identifier (URI).</param>
+        /// <seealso cref="PublicId"/>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="Stream"/>
+        /// <seealso cref="TextReader"/>
+        /// <seealso cref="Encoding"/>
+        public InputSource(string systemId)
+        {
+            this.systemId = systemId;
+        }
+
+        /// <summary>
+        /// Create a new input source with a byte stream.
+        /// </summary>
+        /// <remarks>
+        /// Application writers should use <see cref="SystemId"/> to provide a 
base 
+        /// for resolving relative URIs, may use <see cref="PublicId"/> to 
include a 
+        /// public identifier, and may use <see cref="Encoding"/> to specify 
the object's
+        /// character encoding.
+        /// </remarks>
+        /// <param name="byteStream">The raw byte stream containing the 
document.</param>
+        /// <seealso cref="PublicId"/>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="Encoding"/>
+        /// <seealso cref="Stream"/>
+        /// <seealso cref="TextReader"/>
+        public InputSource(Stream byteStream)
+        {
+            this.byteStream = byteStream;
+        }
+
+        /// <summary>
+        /// Create a new input source with a character stream.
+        /// </summary>
+        /// <remarks>
+        /// Application writers should use <see cref="SystemId"/> to provide a 
base 
+        /// for resolving relative URIs, and may use <see cref="PublicId"/> to 
include a
+        /// public identifier.
+        /// <para/>
+        /// The character stream shall not include a byte order mark.
+        /// </remarks>
+        /// <param name="characterStream"></param>
+        /// <seealso cref="PublicId"/>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="Stream"/>
+        /// <seealso cref="TextReader"/>
+        public InputSource(TextReader characterStream)
+        {
+            this.characterStream = characterStream;
+        }
+
+        /// <summary>
+        /// Gets or Sets the public identifier for this input source.
+        /// </summary>
+        /// <remarks>
+        /// The public identifier is always optional: if the application
+        /// writer includes one, it will be provided as part of the
+        /// location information.
+        /// </remarks>
+        /// <seealso cref="ILocator.PublicId"/>
+        /// <seealso cref="SAXParseException.PublicId"/>
+        public virtual string PublicId
+        {
+            get { return publicId; }
+            set { publicId = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the system identifier for this input source.
+        /// </summary>
+        /// <remarks>
+        /// The system identifier is optional if there is a byte stream
+        /// or a character stream, but it is still useful to provide one,
+        /// since the application can use it to resolve relative URIs
+        /// and can include it in error messages and warnings(the parser
+        /// will attempt to open a connection to the URI only if
+        /// there is no byte stream or character stream specified).
+        /// <para/>
+        /// If the application knows the character encoding of the
+        /// object pointed to by the system identifier, it can register
+        /// the encoding using the <see cref="Encoding"/> property setter.
+        /// <para/>
+        /// If the system identifier is a URL, it must be fully
+        /// resolved(it may not be a relative URL).
+        /// </remarks>
+        /// <seealso cref="Encoding"/>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="ILocator.SystemId"/>
+        /// <seealso cref="SAXParseException.SystemId"/>
+        public virtual string SystemId
+        {
+            get { return systemId; }
+            set { systemId = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the byte stream for this input source.
+        /// </summary>
+        /// <remarks>
+        /// The SAX parser will ignore this if there is also a character
+        /// stream specified, but it will use a byte stream in preference
+        /// to opening a URI connection itself.
+        /// <para/>
+        /// If the application knows the character encoding of the
+        /// byte stream, it should set it with the setEncoding method.
+        /// </remarks>
+        /// <seealso cref="Encoding"/>
+        /// <seealso cref="Stream"/>
+        /// <seealso cref="System.IO.Stream"/>
+        public virtual Stream Stream
+        {
+            get { return byteStream; }
+            set { byteStream = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the character encoding.
+        /// </summary>
+        /// <remarks>
+        /// The encoding must be a string acceptable for an
+        /// XML encoding declaration(see section 4.3.3 of the XML 1.0
+        /// recommendation).
+        /// <para/>
+        /// This method has no effect when the application provides a
+        /// character stream.
+        /// </remarks>
+        /// <seealso cref="SystemId"/>
+        /// <seealso cref="Stream"/>
+        public virtual Encoding Encoding
+        {
+            get { return encoding; }
+            set { encoding = value; }
+        }
+
+        /// <summary>
+        /// Gets or Sets the character stream for this input source.
+        /// </summary>
+        /// <remarks>
+        /// If there is a character stream specified, the SAX parser
+        /// will ignore any byte stream and will not attempt to open
+        /// a URI connection to the system identifier.
+        /// </remarks>
+        /// <seealso cref="System.IO.TextReader"/>
+        public virtual TextReader TextReader
+        {
+            get { return characterStream; }
+            set { characterStream = value; }
+        }
+
+        ////////////////////////////////////////////////////////////////////
+        // Internal state.
+        ////////////////////////////////////////////////////////////////////
+
+        private string publicId;
+        private string systemId;
+        private Stream byteStream;
+        private Encoding encoding;
+        private TextReader characterStream;
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/Locator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/Locator.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/Locator.cs
new file mode 100644
index 0000000..25d1fce
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/Locator.cs
@@ -0,0 +1,125 @@
+// SAX locator interface for document events.
+// http://www.saxproject.org
+// No warranty; no copyright -- use this as you will.
+// $Id: Locator.java,v 1.8 2002/01/30 21:13:47 dbrownell Exp $
+
+namespace Sax
+{
+    /// <summary>
+    /// Interface for associating a SAX event with a document location.
+    /// </summary>
+    /// <remarks>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
+    /// See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// If a SAX parser provides location information to the SAX
+    /// application, it does so by implementing this interface and then
+    /// passing an instance to the application using the content
+    /// handler's <see cref="IContentHandler.SetDocumentLocator(ILocator)"/>
+    /// method.The application can use the
+    /// object to obtain the location of any other SAX event
+    /// in the XML source document.
+    /// <para/>
+    /// Note that the results returned by the object will be valid only
+    /// during the scope of each callback method: the application
+    /// will receive unpredictable results if it attempts to use the
+    /// locator at any other time, or after parsing completes.
+    /// <para/>
+    /// SAX parsers are not required to supply a locator, but they are
+    /// very strongly encouraged to do so.  If the parser supplies a
+    /// locator, it must do so before reporting any other document events.
+    /// If no locator has been set by the time the application receives
+    /// the <see cref="IContentHandler.StartDocument()"/>
+    /// event, the application should assume that a locator is not
+    /// available.
+    /// </remarks>
+    /// <since>SAX 1.0</since>
+    /// <author>David Megginson</author>
+    /// <version>2.0.1 (sax2r2)</version>
+    /// <seealso cref="IContentHandler.SetDocumentLocator(ILocator)"/>
+    public interface ILocator
+    {
+        /// <summary>
+        /// Gets the public identifier for the current document event.
+        /// <para/>
+        /// The return value is the public identifier of the document
+        /// entity or of the external parsed entity in which the markup
+        /// triggering the event appears.
+        /// <para/>
+        /// Returns a string containing the public identifier, or null if none 
is available.
+        /// </summary>
+        /// <seealso cref="SystemId"/>
+        string PublicId { get; }
+
+        /// <summary>
+        /// Return the system identifier for the current document event.
+        /// <para/>
+        /// The return value is the system identifier of the document
+        /// entity or of the external parsed entity in which the markup
+        /// triggering the event appears.
+        /// <para/>If the system identifier is a URL, the parser must resolve 
it
+        /// fully before passing it to the application.  For example, a file
+        /// name must always be provided as a <em>file:...</em> URL, and other
+        /// kinds of relative URI are also resolved against their bases.
+        /// <para/>
+        /// Returns a string containing the system identifier, or null
+        /// if none is available.
+        /// </summary>
+        /// <seealso cref="PublicId"/>
+        string SystemId { get; }
+
+        /// <summary>
+        /// Return the line number where the current document event ends.
+        /// Lines are delimited by line ends, which are defined in
+        /// the XML specification.
+        /// <para/>
+        /// <strong>Warning:</strong> The return value from the method
+        /// is intended only as an approximation for the sake of diagnostics;
+        /// it is not intended to provide sufficient information
+        /// to edit the character content of the original XML document.
+        /// In some cases, these "line" numbers match what would be displayed
+        /// as columns, and in others they may not match the source text
+        /// due to internal entity expansion. 
+        /// <para/>
+        /// The return value is an approximation of the line number
+        /// in the document entity or external parsed entity where the
+        /// markup triggering the event appears.
+        /// <para/>
+        /// If possible, the SAX driver should provide the line position 
+        /// of the first character after the text associated with the document 
+        /// event.  The first line is line 1.
+        /// <para/>
+        /// Returns the line number, or -1 if none is available.
+        /// </summary>
+        /// <seealso cref="ColumnNumber"/>
+        int LineNumber { get; }
+
+        /// <summary>
+        /// Return the column number where the current document event ends.
+        /// This is one-based number of Java<code>char</code> values since
+        /// the last line end.
+        /// <para/>
+        /// <strong>Warning:</strong> The return value from the method
+        /// is intended only as an approximation for the sake of diagnostics;
+        /// it is not intended to provide sufficient information
+        /// to edit the character content of the original XML document.
+        /// For example, when lines contain combining character sequences, wide
+        /// characters, surrogate pairs, or bi-directional text, the value may
+        /// not correspond to the column in a text editor's display. 
+        /// <para/>
+        /// The return value is an approximation of the column number
+        /// in the document entity or external parsed entity where the
+        /// markup triggering the event appears.
+        /// <para/>
+        /// If possible, the SAX driver should provide the line position 
+        /// of the first character after the text associated with the document 
+        /// event.  The first column in each line is column 1.
+        /// <para/>
+        /// Returns the column number, or -1 if none is available.
+        /// </summary>
+        /// <seealso cref="LineNumber"/>
+        int ColumnNumber { get; }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/SAXException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/SAXException.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/SAXException.cs
new file mode 100644
index 0000000..fc075d8
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/SAXException.cs
@@ -0,0 +1,165 @@
+// SAX exception class.
+// http://www.saxproject.org
+// No warranty; no copyright -- use this as you will.
+// $Id: SAXException.java,v 1.7 2002/01/30 21:13:48 dbrownell Exp $
+
+using System;
+#if FEATURE_SERIALIZABLE
+using System.Runtime.Serialization;
+#endif
+
+namespace Sax
+{
+    /// <summary>
+    /// Encapsulate a general SAX error or warning.
+    /// </summary>
+    /// <remarks>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em>
+    /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// This class can contain basic error or warning information from
+    /// either the XML parser or the application: a parser writer or
+    /// application writer can subclass it to provide additional
+    /// functionality. SAX handlers may throw this exception or
+    /// any exception subclassed from it.
+    /// <para/>
+    /// If the application needs to pass through other types of
+    /// exceptions, it must wrap those exceptions in a <see 
cref="SAXException"/>
+    /// or an exception derived from a <see cref="SAXException"/>.
+    /// <para/>
+    /// If the parser or application needs to include information about a
+    /// specific location in an XML document, it should use the
+    /// <see cref="SAXParseException"/> subclass.
+    /// </remarks>
+    // LUCENENET: All exeption classes should be marked serializable
+#if FEATURE_SERIALIZABLE
+    [Serializable]
+#endif
+    public class SAXException : Exception
+    {
+        /// <summary>
+        /// Create a new <see cref="SAXException"/>.
+        /// </summary>
+        public SAXException()
+            : base()
+        {
+            this.exception = null;
+        }
+
+        /// <summary>
+        /// Create a new <see cref="SAXException"/>.
+        /// </summary>
+        /// <param name="message">The error or warning message.</param>
+        public SAXException(string message)
+            : base(message)
+        {
+            this.exception = null;
+        }
+
+        /// <summary>
+        /// Create a new <see cref="SAXException"/> wrapping an existing 
exception.
+        /// </summary>
+        /// <remarks>
+        /// The existing exception will be embedded in the new
+        /// one, and its message will become the default message for
+        /// the <see cref="SAXException"/>.
+        /// </remarks>
+        /// <param name="e">The exception to be wrapped in a <see 
cref="SAXException"/>.</param>
+        public SAXException(Exception e)
+            : base()
+        {
+            this.exception = e;
+        }
+
+        /// <summary>
+        /// Create a new <see cref="SAXException"/> from an existing exception.
+        /// </summary>
+        /// <remarks>
+        /// The existing exception will be embedded in the new
+        /// one, but the new exception will have its own message.
+        /// </remarks>
+        /// <param name="message">The detail message.</param>
+        /// <param name="e">The exception to be wrapped in a 
SAXException.</param>
+        public SAXException(string message, Exception e)
+            : base(message)
+        {
+            this.exception = e;
+        }
+
+#if FEATURE_SERIALIZABLE
+        /// <summary>
+        /// Initializes a new instance of this class with serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds 
the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that 
contains contextual information about the source or destination.</param>
+        public SAXException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+
+        /// <summary>
+        /// Return a detail message for this exception.
+        /// </summary>
+        /// <remarks>
+        /// If there is an embedded exception, and if the SAXException
+        /// has no detail message of its own, this method will return
+        /// the detail message from the embedded exception.
+        /// </remarks>
+        public override string Message
+        {
+            get
+            {
+                string message = base.Message;
+
+                if (message == null && exception != null)
+                {
+                    return exception.Message;
+                }
+                else
+                {
+                    return message;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the embedded exception, if any, or <c>null</c> if there is 
none.
+        /// </summary>
+        public virtual Exception Exception
+        {
+            get { return exception; }
+        }
+
+        /// <summary>
+        /// Override ToString to pick up any embedded exception.
+        /// </summary>
+        /// <returns>A string representation of this exception.</returns>
+        public override string ToString()
+        {
+            if (exception != null)
+            {
+                return exception.ToString();
+            }
+            else
+            {
+                return base.ToString();
+            }
+        }
+
+
+
+        //////////////////////////////////////////////////////////////////////
+        // Internal state.
+        //////////////////////////////////////////////////////////////////////
+
+
+        /// <summary>
+        /// The embedded exception if tunnelling, or null.
+        /// </summary>
+        private Exception exception;
+
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/SAXNotRecognizedException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/SAXNotRecognizedException.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/SAXNotRecognizedException.cs
new file mode 100644
index 0000000..e0ef4f5
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/SAXNotRecognizedException.cs
@@ -0,0 +1,66 @@
+// SAXNotRecognizedException.java - unrecognized feature or value.
+// http://www.saxproject.org
+// Written by David Megginson
+// NO WARRANTY!  This class is in the Public Domain.
+// $Id: SAXNotRecognizedException.java,v 1.7 2002/01/30 21:13:48 dbrownell Exp 
$
+
+using System;
+#if FEATURE_SERIALIZABLE
+using System.Runtime.Serialization;
+#endif
+
+namespace Sax
+{
+    /// <summary>
+    /// Exception class for an unrecognized identifier.
+    /// </summary>
+    /// <remarks>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em>
+    /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// An XMLReader will throw this exception when it finds an
+    /// unrecognized feature or property identifier; SAX applications and
+    /// extensions may use this class for other, similar purposes.
+    /// </remarks>
+    /// <since>SAX 2.0</since>
+    /// <author>David Megginson</author>
+    /// <version>2.0.1 (sax2r2)</version>
+    /// <see cref="SAXNotSupportedException"/>
+    // LUCENENET: All exeption classes should be marked serializable
+#if FEATURE_SERIALIZABLE
+    [Serializable]
+#endif
+    public class SAXNotRecognizedException : SAXException
+    {
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public SAXNotRecognizedException()
+            : base() 
+        {
+        }
+
+        /// <summary>
+        /// Construct a new exception with the given message.
+        /// </summary>
+        /// <param name="message">The text message of the exception.</param>
+        public SAXNotRecognizedException(string message)
+            : base(message)
+        {
+        }
+
+#if FEATURE_SERIALIZABLE
+        /// <summary>
+        /// Initializes a new instance of this class with serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds 
the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that 
contains contextual information about the source or destination.</param>
+        public SAXNotRecognizedException(SerializationInfo info, 
StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/198e5868/src/Lucene.Net.Benchmark/Support/Sax/SAXNotSupportedException.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Benchmark/Support/Sax/SAXNotSupportedException.cs 
b/src/Lucene.Net.Benchmark/Support/Sax/SAXNotSupportedException.cs
new file mode 100644
index 0000000..d5184c9
--- /dev/null
+++ b/src/Lucene.Net.Benchmark/Support/Sax/SAXNotSupportedException.cs
@@ -0,0 +1,67 @@
+// SAXNotSupportedException.java - unsupported feature or value.
+// http://www.saxproject.org
+// Written by David Megginson
+// NO WARRANTY!  This class is in the Public Domain.
+// $Id: SAXNotSupportedException.java,v 1.7 2002/01/30 21:13:48 dbrownell Exp $
+
+using System;
+#if FEATURE_SERIALIZABLE
+using System.Runtime.Serialization;
+#endif
+
+namespace Sax
+{
+    /// <summary>
+    /// Exception class for an unsupported operation.
+    /// </summary>
+    /// <remarks>
+    /// <em>This module, both source code and documentation, is in the
+    /// Public Domain, and comes with<strong> NO WARRANTY</strong>.</em>
+    /// See<a href='http://www.saxproject.org'>http://www.saxproject.org</a>
+    /// for further information.
+    /// <para/>
+    /// An XMLReader will throw this exception when it recognizes a
+    /// feature or property identifier, but cannot perform the requested
+    /// operation(setting a state or value).  Other SAX2 applications and
+    /// extensions may use this class for similar purposes.
+    /// </remarks>
+    /// <since>SAX 2.0</since>
+    /// <author>David Megginson</author>
+    /// <version>2.0.1 (sax2r2)</version>
+    /// <seealso cref="SAXNotRecognizedException"/>
+    // LUCENENET: All exeption classes should be marked serializable
+#if FEATURE_SERIALIZABLE
+    [Serializable]
+#endif
+    public class SAXNotSupportedException : SAXException
+    {
+        /// <summary>
+        /// Construct a new exception with no message.
+        /// </summary>
+        public SAXNotSupportedException()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// Construct a new exception with the given message.
+        /// </summary>
+        /// <param name="message">The text message of the exception.</param>
+        public SAXNotSupportedException(string message)
+            : base(message)
+        {
+        }
+
+#if FEATURE_SERIALIZABLE
+        /// <summary>
+        /// Initializes a new instance of this class with serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds 
the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that 
contains contextual information about the source or destination.</param>
+        public SAXNotSupportedException(SerializationInfo info, 
StreamingContext context)
+            : base(info, context)
+        {
+        }
+#endif
+    }
+}

Reply via email to