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 + } +}
