You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/08/06 17:59:20 UTC
[22/33] lucenenet git commit: Lucene.Net.Benchmark: Added Sax and
TagSoup to the Support folder.
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
+ }
+}