content: /**
   * (The MIT License)
   *
   * Copyright (c) 2008 - 2011:
   *
   * * {Aaron Patterson}[http://tenderlovemaking.com]
   * * {Mike Dalessio}[http://mike.daless.io]
   * * {Charles Nutter}[http://blog.headius.com]
   * * {Sergio Arbeo}[http://www.serabe.com]
   * * {Patrick Mahoney}[http://polycrystal.org]
   * * {Yoko Harada}[http://yokolet.blogspot.com]
   *
   * Permission is hereby granted, free of charge, to any person obtaining
   * a copy of this software and associated documentation files (the
   * 'Software'), to deal in the Software without restriction, including
   * without limitation the rights to use, copy, modify, merge, publish,
   * distribute, sublicense, and/or sell copies of the Software, and to
   * permit persons to whom the Software is furnished to do so, subject to
   * the following conditions:
   * 
   * The above copyright notice and this permission notice shall be
   * included in all copies or substantial portions of the Software.
   * 
   * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   */
  
  package nokogiri;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.jruby.Ruby;
  import org.jruby.RubyArray;
  import org.jruby.RubyClass;
  import org.jruby.RubyFixnum;
  import org.jruby.RubyModule;
  import org.jruby.runtime.ObjectAllocator;
  import org.jruby.runtime.builtin.IRubyObject;
  import org.jruby.runtime.load.BasicLibraryService;
  
  /**
   * Class to provide Nokogiri. This class is used to make "require 'nokogiri'" work
   * in JRuby. Also, this class holds a Ruby type cache and allocators of Ruby types.
   * 
   * @author headius
   * @author Yoko Harada <yokolet@gmail.com>
   */
  public class NokogiriService implements BasicLibraryService {
      public static final String nokogiriClassCacheGvarName = "$NOKOGIRI_CLASS_CACHE";
      public static Map<String, RubyClass> nokogiriClassCache;
  
      public boolean basicLoad(Ruby ruby) {
          init(ruby);
          createNokogiriClassCahce(ruby);
          return true;
      }
      
      private static void createNokogiriClassCahce(Ruby ruby) {
          nokogiriClassCache = Collections.synchronizedMap(new HashMap<String, RubyClass>());
          nokogiriClassCache.put("Nokogiri::EncodingHandler", (RubyClass)ruby.getClassFromPath("Nokogiri::EncodingHandler"));
          nokogiriClassCache.put("Nokogiri::HTML::Document", (RubyClass)ruby.getClassFromPath("Nokogiri::HTML::Document"));
          nokogiriClassCache.put("Nokogiri::HTML::ElementDescription", (RubyClass)ruby.getClassFromPath("Nokogiri::HTML::ElementDescription"));
          nokogiriClassCache.put("Nokogiri::XML::Attr", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Attr"));
          nokogiriClassCache.put("Nokogiri::XML::Document", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Document"));
          nokogiriClassCache.put("Nokogiri::XML::DocumentFragment", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::DocumentFragment"));
          nokogiriClassCache.put("Nokogiri::XML::DTD", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::DTD"));
          nokogiriClassCache.put("Nokogiri::XML::Text", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Text"));
          nokogiriClassCache.put("Nokogiri::XML::Comment", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Comment"));
          nokogiriClassCache.put("Nokogiri::XML::Element", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Element"));
          nokogiriClassCache.put("Nokogiri::XML::ElementContent", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::ElementContent"));
          nokogiriClassCache.put("Nokogiri::XML::ElementDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::ElementDecl"));
          nokogiriClassCache.put("Nokogiri::XML::EntityDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::EntityDecl"));
          nokogiriClassCache.put("Nokogiri::XML::EntityReference", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::EntityReference"));
          nokogiriClassCache.put("Nokogiri::XML::ProcessingInstruction", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::ProcessingInstruction"));
          nokogiriClassCache.put("Nokogiri::XML::CDATA", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::CDATA"));
          nokogiriClassCache.put("Nokogiri::XML::Node", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Node"));
          nokogiriClassCache.put("Nokogiri::XML::NodeSet", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::NodeSet"));
          nokogiriClassCache.put("Nokogiri::XML::Namespace", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Namespace"));
          nokogiriClassCache.put("Nokogiri::XML::SyntaxError", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::SyntaxError"));
          nokogiriClassCache.put("Nokogiri::XML::Reader", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Reader"));
          nokogiriClassCache.put("Nokogiri::XML::RelaxNG", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::RelaxNG"));
          nokogiriClassCache.put("Nokogiri::XML::Schema", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Schema"));
          nokogiriClassCache.put("Nokogiri::XML::XPathContext", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::XPathContext"));
          nokogiriClassCache.put("Nokogiri::XML::AttributeDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::AttributeDecl"));
          nokogiriClassCache.put("Nokogiri::XML::SAX::ParserContext", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::SAX::ParserContext"));
      }
  
      private void init(Ruby ruby) {
          RubyModule nokogiri = ruby.defineModule("Nokogiri");
          RubyModule xmlModule = nokogiri.defineModuleUnder("XML");
          RubyModule xmlSaxModule = xmlModule.defineModuleUnder("SAX");
          RubyModule htmlModule = nokogiri.defineModuleUnder("HTML");
          RubyModule htmlSaxModule = htmlModule.defineModuleUnder("SAX");
          RubyModule xsltModule = nokogiri.defineModuleUnder("XSLT");
  
          createNokogiriModule(ruby, nokogiri);
          createSyntaxErrors(ruby, nokogiri, xmlModule);
          RubyClass xmlNode = createXmlModule(ruby, xmlModule);
          createHtmlModule(ruby, htmlModule);
          createDocuments(ruby, xmlModule, htmlModule, xmlNode);
          createSaxModule(ruby, xmlSaxModule, htmlSaxModule);
          createXsltModule(ruby, xsltModule);
      }
      
      private void createNokogiriModule(Ruby ruby, RubyModule nokogiri) {;
          RubyClass encHandler = nokogiri.defineClassUnder("EncodingHandler", ruby.getObject(), ENCODING_HANDLER_ALLOCATOR);
          encHandler.defineAnnotatedMethods(EncodingHandler.class);
      }
      
      private void createSyntaxErrors(Ruby ruby, RubyModule nokogiri, RubyModule xmlModule) {
          RubyClass syntaxError = nokogiri.defineClassUnder("SyntaxError", ruby.getStandardError(), ruby.getStandardError().getAllocator());
          RubyClass xmlSyntaxError = xmlModule.defineClassUnder("SyntaxError", syntaxError, XML_SYNTAXERROR_ALLOCATOR);
          xmlSyntaxError.defineAnnotatedMethods(XmlSyntaxError.class);
      }
      
      private RubyClass createXmlModule(Ruby ruby, RubyModule xmlModule) {
          RubyClass node = xmlModule.defineClassUnder("Node", ruby.getObject(), XML_NODE_ALLOCATOR);
          node.defineAnnotatedMethods(XmlNode.class);
          
          RubyClass attr = xmlModule.defineClassUnder("Attr", node, XML_ATTR_ALLOCATOR);
          attr.defineAnnotatedMethods(XmlAttr.class);
          
          RubyClass attrDecl = xmlModule.defineClassUnder("AttributeDecl", node, XML_ATTRIBUTE_DECL_ALLOCATOR);
          attrDecl.defineAnnotatedMethods(XmlAttributeDecl.class);
          
          RubyClass characterData = xmlModule.defineClassUnder("CharacterData", node, null);
          
          RubyClass comment = xmlModule.defineClassUnder("Comment", characterData, XML_COMMENT_ALLOCATOR);
          comment.defineAnnotatedMethods(XmlComment.class);
          
          RubyClass text = xmlModule.defineClassUnder("Text", characterData, XML_TEXT_ALLOCATOR);
          text.defineAnnotatedMethods(XmlText.class);
          
          RubyModule cdata = xmlModule.defineClassUnder("CDATA", text, XML_CDATA_ALLOCATOR);
          cdata.defineAnnotatedMethods(XmlCdata.class);
          
          RubyClass dtd = xmlModule.defineClassUnder("DTD", node, XML_DTD_ALLOCATOR);
          dtd.defineAnnotatedMethods(XmlDtd.class);
  
          RubyClass documentFragment = xmlModule.defineClassUnder("DocumentFragment", node, XML_DOCUMENT_FRAGMENT_ALLOCATOR);
          documentFragment.defineAnnotatedMethods(XmlDocumentFragment.class);
          
          RubyClass element = xmlModule.defineClassUnder("Element", node, XML_ELEMENT_ALLOCATOR);
          element.defineAnnotatedMethods(XmlElement.class);
          
          RubyClass elementContent = xmlModule.defineClassUnder("ElementContent", ruby.getObject(), XML_ELEMENT_CONTENT_ALLOCATOR);
          elementContent.defineAnnotatedMethods(XmlElementContent.class);
          
          RubyClass elementDecl = xmlModule.defineClassUnder("ElementDecl", node, XML_ELEMENT_DECL_ALLOCATOR);
          elementDecl.defineAnnotatedMethods(XmlElementDecl.class);
          
          RubyClass entityDecl = xmlModule.defineClassUnder("EntityDecl", node, XML_ENTITY_DECL_ALLOCATOR);
          entityDecl.defineAnnotatedMethods(XmlEntityDecl.class);
          
          entityDecl.defineConstant("INTERNAL_GENERAL", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_GENERAL));
          entityDecl.defineConstant("EXTERNAL_GENERAL_PARSED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_GENERAL_PARSED));
          entityDecl.defineConstant("EXTERNAL_GENERAL_UNPARSED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_GENERAL_UNPARSED));
          entityDecl.defineConstant("INTERNAL_PARAMETER", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_PARAMETER));
          entityDecl.defineConstant("EXTERNAL_PARAMETER", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_PARAMETER));
          entityDecl.defineConstant("INTERNAL_PREDEFINED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_PREDEFINED));
          
          RubyClass entref = xmlModule.defineClassUnder("EntityReference", node, XML_ENTITY_REFERENCE_ALLOCATOR);
          entref.defineAnnotatedMethods(XmlEntityReference.class);
          
          RubyClass namespace = xmlModule.defineClassUnder("Namespace", ruby.getObject(), XML_NAMESPACE_ALLOCATOR);
          namespace.defineAnnotatedMethods(XmlNamespace.class);
          
          RubyClass nodeSet = xmlModule.defineClassUnder("NodeSet", ruby.getObject(), XML_NODESET_ALLOCATOR);
          nodeSet.defineAnnotatedMethods(XmlNodeSet.class);
          
          RubyClass pi = xmlModule.defineClassUnder("ProcessingInstruction", node, XML_PROCESSING_INSTRUCTION_ALLOCATOR);
          pi.defineAnnotatedMethods(XmlProcessingInstruction.class);
          
          RubyClass reader = xmlModule.defineClassUnder("Reader", ruby.getObject(), XML_READER_ALLOCATOR);
          reader.defineAnnotatedMethods(XmlReader.class);
          
          RubyClass schema = xmlModule.defineClassUnder("Schema", ruby.getObject(), XML_SCHEMA_ALLOCATOR);
          schema.defineAnnotatedMethods(XmlSchema.class);
  
          RubyClass relaxng = xmlModule.defineClassUnder("RelaxNG", schema, XML_RELAXNG_ALLOCATOR);
          relaxng.defineAnnotatedMethods(XmlRelaxng.class);
          
          RubyClass xpathContext = xmlModule.defineClassUnder("XPathContext", ruby.getObject(), XML_XPATHCONTEXT_ALLOCATOR);
          xpathContext.defineAnnotatedMethods(XmlXpathContext.class);
          
          return node;
      }
  
      private void createHtmlModule(Ruby ruby, RubyModule htmlModule) {
          RubyClass htmlElemDesc = htmlModule.defineClassUnder("ElementDescription", ruby.getObject(), HTML_ELEMENT_DESCRIPTION_ALLOCATOR);
          htmlElemDesc.defineAnnotatedMethods(HtmlElementDescription.class);
          
          RubyClass htmlEntityLookup = htmlModule.defineClassUnder("EntityLookup", ruby.getObject(), HTML_ENTITY_LOOKUP_ALLOCATOR);
          htmlEntityLookup.defineAnnotatedMethods(HtmlEntityLookup.class);
      }
      
      private void createDocuments(Ruby ruby, RubyModule xmlModule, RubyModule htmlModule, RubyClass node) {
          RubyClass xmlDocument = xmlModule.defineClassUnder("Document", node, XML_DOCUMENT_ALLOCATOR);
          xmlDocument.defineAnnotatedMethods(XmlDocument.class);
          
          //RubyModule htmlDoc = html.defineOrGetClassUnder("Document", document);
          RubyModule htmlDocument = htmlModule.defineClassUnder("Document", xmlDocument, HTML_DOCUMENT_ALLOCATOR);
          htmlDocument.defineAnnotatedMethods(HtmlDocument.class);
      }
      
      private void createSaxModule(Ruby ruby, RubyModule xmlSaxModule, RubyModule htmlSaxModule) {
          RubyClass xmlSaxParserContext = xmlSaxModule.defineClassUnder("ParserContext", ruby.getObject(), XML_SAXPARSER_CONTEXT_ALLOCATOR);
          xmlSaxParserContext.defineAnnotatedMethods(XmlSaxParserContext.class);
          
          RubyClass xmlSaxPushParser = xmlSaxModule.defineClassUnder("PushParser", ruby.getObject(), XML_SAXPUSHPARSER_ALLOCATOR);
          xmlSaxPushParser.defineAnnotatedMethods(XmlSaxPushParser.class);
          
          RubyClass htmlSaxParserContext = htmlSaxModule.defineClassUnder("ParserContext", xmlSaxParserContext, HTML_SAXPARSER_CONTEXT_ALLOCATOR);
          htmlSaxParserContext.defineAnnotatedMethods(HtmlSaxParserContext.class);
      }
      
      private void createXsltModule(Ruby ruby, RubyModule xsltModule) {
          RubyClass stylesheet = xsltModule.defineClassUnder("Stylesheet", ruby.getObject(), XSLT_STYLESHEET_ALLOCATOR);
          stylesheet.defineAnnotatedMethods(XsltStylesheet.class);
          xsltModule.defineAnnotatedMethod(XsltStylesheet.class, "register");
      }
  
      private static ObjectAllocator ENCODING_HANDLER_ALLOCATOR = new ObjectAllocator() {
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              return new EncodingHandler(runtime, klazz, "");
          }
      };
  
      public static final ObjectAllocator HTML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
          private HtmlDocument htmlDocument = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (htmlDocument == null) htmlDocument = new HtmlDocument(runtime, klazz);
              try {
                  HtmlDocument clone = (HtmlDocument) htmlDocument.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new HtmlDocument(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator HTML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
          private HtmlSaxParserContext htmlSaxParserContext = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (htmlSaxParserContext == null) htmlSaxParserContext = new HtmlSaxParserContext(runtime, klazz);
              try {
                  HtmlSaxParserContext clone = (HtmlSaxParserContext) htmlSaxParserContext.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new HtmlSaxParserContext(runtime, klazz);
              }
          }
      };
  
      private static ObjectAllocator HTML_ELEMENT_DESCRIPTION_ALLOCATOR =
          new ObjectAllocator() {
              public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
                  return new HtmlElementDescription(runtime, klazz);
              }
          };
  
      private static ObjectAllocator HTML_ENTITY_LOOKUP_ALLOCATOR =
          new ObjectAllocator() {
              public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
                  return new HtmlEntityLookup(runtime, klazz);
              }
          };
  
      public static final ObjectAllocator XML_ATTR_ALLOCATOR = new ObjectAllocator() {
          private XmlAttr xmlAttr = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlAttr == null) xmlAttr = new XmlAttr(runtime, klazz);
              try {
                  XmlAttr clone = (XmlAttr) xmlAttr.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlAttr(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_CDATA_ALLOCATOR = new ObjectAllocator() {
          private XmlCdata xmlCdata = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlCdata == null) xmlCdata = new XmlCdata(runtime, klazz);
              try {
                  XmlCdata clone = (XmlCdata) xmlCdata.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlCdata(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_COMMENT_ALLOCATOR = new ObjectAllocator() {
          private XmlComment xmlComment = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlComment == null) xmlComment = new XmlComment(runtime, klazz);
              try {
                  XmlComment clone = (XmlComment) xmlComment.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlComment(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
          private XmlDocument xmlDocument = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlDocument == null) xmlDocument = new XmlDocument(runtime, klazz);
              try {
                  XmlDocument clone = (XmlDocument) xmlDocument.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlDocument(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_DOCUMENT_FRAGMENT_ALLOCATOR = new ObjectAllocator() {
          private XmlDocumentFragment xmlDocumentFragment = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlDocumentFragment == null) xmlDocumentFragment = new XmlDocumentFragment(runtime, klazz);
              try {
                  XmlDocumentFragment clone = (XmlDocumentFragment)xmlDocumentFragment.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlDocumentFragment(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_DTD_ALLOCATOR = new ObjectAllocator() {
          private XmlDtd xmlDtd = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlDtd == null) xmlDtd = new XmlDtd(runtime, klazz);
              try {
                  XmlDtd clone = (XmlDtd)xmlDtd.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlDtd(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_ELEMENT_ALLOCATOR = new ObjectAllocator() {
          private XmlElement xmlElement = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlElement == null) xmlElement = new XmlElement(runtime, klazz);
              try {
                  XmlElement clone = (XmlElement)xmlElement.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlElement(runtime, klazz);
              }
          }
      };
      
      public static ObjectAllocator XML_ELEMENT_DECL_ALLOCATOR = new ObjectAllocator() {
          private XmlElementDecl xmlElementDecl = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlElementDecl == null) xmlElementDecl = new XmlElementDecl(runtime, klazz);
              try {
                  XmlElementDecl clone = (XmlElementDecl)xmlElementDecl.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlElementDecl(runtime, klazz);
              }
          }
      };
  
      public static ObjectAllocator XML_ENTITY_REFERENCE_ALLOCATOR = new ObjectAllocator() {
          private XmlEntityReference xmlEntityRef = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlEntityRef == null) xmlEntityRef = new XmlEntityReference(runtime, klazz);
              try {
                  XmlEntityReference clone = (XmlEntityReference)xmlEntityRef.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlEntityReference(runtime, klazz);
              }
          }
      };
      
      public static final ObjectAllocator XML_NAMESPACE_ALLOCATOR = new ObjectAllocator() {
          private XmlNamespace xmlNamespace = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlNamespace == null) xmlNamespace = new XmlNamespace(runtime, klazz);
              try {
                  XmlNamespace clone = (XmlNamespace) xmlNamespace.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlNamespace(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_NODE_ALLOCATOR = new ObjectAllocator() {
          private XmlNode xmlNode = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlNode == null) xmlNode = new XmlNode(runtime, klazz);
              try {
                  XmlNode clone  = (XmlNode) xmlNode.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlNode(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_NODESET_ALLOCATOR = new ObjectAllocator() {
          private XmlNodeSet xmlNodeSet = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlNodeSet == null) xmlNodeSet = new XmlNodeSet(runtime, klazz);
              try {
                  XmlNodeSet clone  = (XmlNodeSet) xmlNodeSet.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  xmlNodeSet = new XmlNodeSet(runtime, klazz);
                  xmlNodeSet.setNodes(RubyArray.newEmptyArray(runtime));
                  return xmlNodeSet;
              }
          }
      };
      
      public static ObjectAllocator XML_PROCESSING_INSTRUCTION_ALLOCATOR = new ObjectAllocator() {
          private XmlProcessingInstruction xmlProcessingInstruction = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlProcessingInstruction == null) xmlProcessingInstruction = new XmlProcessingInstruction(runtime, klazz);
              try {
                  XmlProcessingInstruction clone = (XmlProcessingInstruction)xmlProcessingInstruction.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlProcessingInstruction(runtime, klazz);
              }
          }
      };
  
      public static ObjectAllocator XML_READER_ALLOCATOR = new ObjectAllocator() {
          private XmlReader xmlReader = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlReader == null) xmlReader = new XmlReader(runtime, klazz);
              try {
                  XmlReader clone  = (XmlReader) xmlReader.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  xmlReader = new XmlReader(runtime, klazz);
                  return xmlReader;
              }
          }
      };
  
      private static ObjectAllocator XML_ATTRIBUTE_DECL_ALLOCATOR = new ObjectAllocator() {
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              return new XmlAttributeDecl(runtime, klazz);
          }
      };
  
      private static ObjectAllocator XML_ENTITY_DECL_ALLOCATOR = new ObjectAllocator() {
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              return new XmlEntityDecl(runtime, klazz);
          }
      };
  
      private static ObjectAllocator XML_ELEMENT_CONTENT_ALLOCATOR = new ObjectAllocator() {
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              throw runtime.newNotImplementedError("not implemented");
          }
      };
  
      public static final ObjectAllocator XML_RELAXNG_ALLOCATOR = new ObjectAllocator() {
          private XmlRelaxng xmlRelaxng = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlRelaxng == null) xmlRelaxng = new XmlRelaxng(runtime, klazz);
              try {
                  XmlRelaxng clone  = (XmlRelaxng) xmlRelaxng.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlRelaxng(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
          private XmlSaxParserContext xmlSaxParserContext = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlSaxParserContext == null) xmlSaxParserContext = new XmlSaxParserContext(runtime, klazz);
              try {
                  XmlSaxParserContext clone = (XmlSaxParserContext) xmlSaxParserContext.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlSaxParserContext(runtime, klazz);
              }
          }
      };
  
      private static ObjectAllocator XML_SAXPUSHPARSER_ALLOCATOR = new ObjectAllocator() {
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              return new XmlSaxPushParser(runtime, klazz);
          }
      };
  
      public static final ObjectAllocator XML_SCHEMA_ALLOCATOR = new ObjectAllocator() {
          private XmlSchema xmlSchema = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlSchema == null) xmlSchema = new XmlSchema(runtime, klazz);
              try {
                  XmlSchema clone  = (XmlSchema) xmlSchema.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlSchema(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_SYNTAXERROR_ALLOCATOR = new ObjectAllocator() {
          private XmlSyntaxError xmlSyntaxError = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlSyntaxError == null) xmlSyntaxError = new XmlSyntaxError(runtime, klazz);
              try {
                  XmlSyntaxError clone  = (XmlSyntaxError) xmlSyntaxError.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlSyntaxError(runtime, klazz);
              }
          }
      };
  
      public static final ObjectAllocator XML_TEXT_ALLOCATOR = new ObjectAllocator() {
          private XmlText xmlText = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlText == null) xmlText = new XmlText(runtime, klazz);
              try {
                  XmlText clone  = (XmlText) xmlText.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlText(runtime, klazz);
              }
          }
      };
  
      public static ObjectAllocator XML_XPATHCONTEXT_ALLOCATOR = new ObjectAllocator() {
          private XmlXpathContext xmlXpathContext = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xmlXpathContext == null) xmlXpathContext = new XmlXpathContext(runtime, klazz);
              try {
                  XmlXpathContext clone  = (XmlXpathContext) xmlXpathContext.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlXpathContext(runtime, klazz);
              }
          }
      };
  
      public static ObjectAllocator XSLT_STYLESHEET_ALLOCATOR = new ObjectAllocator() {
          private XsltStylesheet xsltStylesheet = null;
          public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
              if (xsltStylesheet == null) xsltStylesheet = new XsltStylesheet(runtime, klazz);
              try {
                  XsltStylesheet clone  = (XsltStylesheet) xsltStylesheet.clone();
                  clone.setMetaClass(klazz);
                  return clone;
              } catch (CloneNotSupportedException e) {
                  return new XmlText(runtime, klazz);
              }
          }
      };
  }
  