Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/proxy/dom4j/Dom4jProxy.java
// $Id: Dom4jProxy.java 9210 2006-02-03 22:15:19Z steveebersole $
package org.hibernate.proxy.dom4j;

import org.dom4j.Element;
import org.dom4j.QName;
import org.dom4j.Namespace;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Entity;
import org.dom4j.Text;
import org.dom4j.Node;
import org.dom4j.Branch;
import org.dom4j.ProcessingInstruction;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.XPath;
import org.dom4j.InvalidXPathException;
import org.dom4j.Visitor;
import org.hibernate.proxy.dom4j.Dom4jLazyInitializer;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.proxy.LazyInitializer;

import java.io.Serializable;
import java.io.Writer;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Iterator;

/**
 * Proxy for "dom4j" entity representations.
 *
 @author Steve Ebersole
 */
public class Dom4jProxy implements HibernateProxy, Element, Serializable {

  private Dom4jLazyInitializer li;

  public Dom4jProxy(Dom4jLazyInitializer li) {
    this.li = li;
  }

  public Object writeReplace() {
    return this;
  }

  public LazyInitializer getHibernateLazyInitializer() {
    return li;
  }

  public QName getQName() {
    return target().getQName();
  }

  public QName getQName(String s) {
    return target().getQName);
  }

  public void setQName(QName qName) {
    target().setQNameqName );
  }

  public Namespace getNamespace() {
    return target().getNamespace();
  }

  public Namespace getNamespaceForPrefix(String s) {
    return target().getNamespaceForPrefix);
  }

  public Namespace getNamespaceForURI(String s) {
    return target().getNamespaceForURI);
  }

  public List getNamespacesForURI(String s) {
    return target().getNamespacesForURI);
  }

  public String getNamespacePrefix() {
    return target().getNamespacePrefix();
  }

  public String getNamespaceURI() {
    return target().getNamespaceURI();
  }

  public String getQualifiedName() {
    return target().getQualifiedName();
  }

  public List additionalNamespaces() {
    return target().additionalNamespaces();
  }

  public List declaredNamespaces() {
    return target().declaredNamespaces();
  }

  public Element addAttribute(String attrName, String text) {
    return target().addAttributeattrName, text );
  }

  public Element addAttribute(QName attrName, String text) {
    return target().addAttributeattrName, text );
  }

  public Element addComment(String text) {
    return target().addCommenttext );
  }

  public Element addCDATA(String text) {
    return target().addCDATAtext );
  }

  public Element addEntity(String name, String text) {
    return target().addEntityname, text );
  }

  public Element addNamespace(String prefix, String uri) {
    return target().addNamespaceprefix, uri );
  }

  public Element addProcessingInstruction(String target, String text) {
    return target().addProcessingInstructiontarget, text );
  }

  public Element addProcessingInstruction(String target, Map data) {
    return target().addProcessingInstructiontarget, data );
  }

  public Element addText(String text) {
    return target().addTexttext );
  }

  public void add(Attribute attribute) {
    target().addattribute );
  }

  public void add(CDATA cdata) {
    target().addcdata );
  }

  public void add(Entity entity) {
    target().addentity );
  }

  public void add(Text text) {
    target().addtext );
  }

  public void add(Namespace namespace) {
    target().addnamespace );
  }

  public boolean remove(Attribute attribute) {
    return target().removeattribute );
  }

  public boolean remove(CDATA cdata) {
    return target().removecdata );
  }

  public boolean remove(Entity entity) {
    return target().removeentity );
  }

  public boolean remove(Namespace namespace) {
    return target().removenamespace );
  }

  public boolean remove(Text text) {
    return target().removetext );
  }

  public boolean supportsParent() {
    return target().supportsParent();
  }

  public Element getParent() {
    return target().getParent();
  }

  public void setParent(Element element) {
    target().setParentelement );
  }

  public Document getDocument() {
    return target().getDocument();
  }

  public void setDocument(Document document) {
    target().setDocumentdocument );
  }

  public boolean isReadOnly() {
    return target().isReadOnly();
  }

  public boolean hasContent() {
    return target().hasContent();
  }

  public String getName() {
    return target().getName();
  }

  public void setName(String name) {
    target().setNamename );
  }

  public String getText() {
    return target().getText();
  }

  public void setText(String text) {
    target().setTexttext );
  }

  public String getTextTrim() {
    return target().getTextTrim();
  }

  public String getStringValue() {
    return target().getStringValue();
  }

  public String getPath() {
    return target().getPath();
  }

  public String getPath(Element element) {
    return target().getPathelement );
  }

  public String getUniquePath() {
    return target().getUniquePath();
  }

  public String getUniquePath(Element element) {
    return target().getUniquePathelement );
  }

  public String asXML() {
    return target().asXML();
  }

  public void write(Writer writerthrows IOException {
    target().writewriter );
  }

  public short getNodeType() {
    return target().getNodeType();
  }

  public String getNodeTypeName() {
    return target().getNodeTypeName();
  }

  public Node detach() {
    Element parent = target().getParent();
    if (parent!=nullparent.remove(this);
    return target().detach();
  }

  public List selectNodes(String xpath) {
    return target().selectNodesxpath );
  }

  public Object selectObject(String xpath) {
    return target().selectObjectxpath );
  }

  public List selectNodes(String xpath, String comparison) {
    return target().selectNodesxpath, comparison );
  }

  public List selectNodes(String xpath, String comparison, boolean removeDups) {
    return target().selectNodesxpath, comparison, removeDups );
  }

  public Node selectSingleNode(String xpath) {
        return target().selectSingleNodexpath );
  }

  public String valueOf(String xpath) {
    return target().valueOfxpath );
  }

  public Number numberValueOf(String xpath) {
    return target().numberValueOfxpath );
  }

  public boolean matches(String xpath) {
    return target().matchesxpath );
  }

  public XPath createXPath(String xpaththrows InvalidXPathException {
    return target().createXPathxpath );
  }

  public Node asXPathResult(Element element) {
    return target().asXPathResultelement );
  }

  public void accept(Visitor visitor) {
    target().acceptvisitor );
  }

  public Object clone() {
    return target().clone();
  }

  public Object getData() {
    return target().getData();
  }

  public void setData(Object data) {
    target().setDatadata );
  }

  public List attributes() {
    return target().attributes();
  }

  public void setAttributes(List list) {
    target().setAttributeslist );
  }

  public int attributeCount() {
    return target().attributeCount();
  }

  public Iterator attributeIterator() {
    return target().attributeIterator();
  }

  public Attribute attribute(int i) {
    return target().attribute);
  }

  public Attribute attribute(String name) {
    return target().attributename );
  }

  public Attribute attribute(QName qName) {
    return target().attributeqName );
  }

  public String attributeValue(String name) {
    return target().attributeValuename );
  }

  public String attributeValue(String name, String defaultValue) {
    return target().attributeValuename, defaultValue );
  }

  public String attributeValue(QName qName) {
    return target().attributeValueqName );
  }

  public String attributeValue(QName qName, String defaultValue) {
    return target().attributeValueqName, defaultValue );
  }

  /**
   @deprecated
   */
  public void setAttributeValue(String name, String value) {
    target().setAttributeValuename, value );
  }

  /**
   @deprecated
   */
  public void setAttributeValue(QName qName, String value) {
    target().setAttributeValueqName, value );
  }

  public Element element(String name) {
    return target().elementname );
  }

  public Element element(QName qName) {
    return target().elementqName );
  }

  public List elements() {
    return target().elements();
  }

  public List elements(String name) {
    return target().elementsname );
  }

  public List elements(QName qName) {
    return target().elementsqName );
  }

  public Iterator elementIterator() {
    return target().elementIterator();
  }

  public Iterator elementIterator(String name) {
    return target().elementIteratorname );

  }

  public Iterator elementIterator(QName qName) {
    return target().elementIteratorqName );
  }

  public boolean isRootElement() {
    return target().isRootElement();
  }

  public boolean hasMixedContent() {
    return target().hasMixedContent();
  }

  public boolean isTextOnly() {
    return target().isTextOnly();
  }

  public void appendAttributes(Element element) {
    target().appendAttributeselement );
  }

  public Element createCopy() {
    return target().createCopy();
  }

  public Element createCopy(String name) {
    return target().createCopyname );
  }

  public Element createCopy(QName qName) {
    return target().createCopyqName );
  }

  public String elementText(String name) {
    return target().elementTextname );
  }

  public String elementText(QName qName) {
    return target().elementTextqName );
  }

  public String elementTextTrim(String name) {
    return target().elementTextTrimname );
  }

  public String elementTextTrim(QName qName) {
    return target().elementTextTrimqName );
  }

  public Node getXPathResult(int i) {
    return target().getXPathResult);
  }

  public Node node(int i) {
    return target().node);
  }

  public int indexOf(Node node) {
    return target().indexOfnode );
  }

  public int nodeCount() {
    return target().nodeCount();
  }

  public Element elementByID(String id) {
    return target().elementByIDid );
  }

  public List content() {
    return target().content();
  }

  public Iterator nodeIterator() {
    return target().nodeIterator();
  }

  public void setContent(List list) {
    target().setContentlist );
  }

  public void appendContent(Branch branch) {
    target().appendContentbranch );
  }

  public void clearContent() {
    target().clearContent();
  }

  public List processingInstructions() {
    return target().processingInstructions();
  }

  public List processingInstructions(String name) {
    return target().processingInstructionsname );
  }

  public ProcessingInstruction processingInstruction(String name) {
    return target().processingInstructionname );
  }

  public void setProcessingInstructions(List list) {
    target().setProcessingInstructionslist );
  }

  public Element addElement(String name) {
    return target().addElementname );
  }

  public Element addElement(QName qName) {
    return target().addElementqName );
  }

  public Element addElement(String name, String text) {
    return target().addElementname, text );

  }

  public boolean removeProcessingInstruction(String name) {
    return target().removeProcessingInstructionname );
  }

  public void add(Node node) {
    target().addnode );
  }

  public void add(Comment comment) {
    target().addcomment );
  }

  public void add(Element element) {
    target().addelement );
  }

  public void add(ProcessingInstruction processingInstruction) {
    target().addprocessingInstruction );
  }

  public boolean remove(Node node) {
    return target().removenode );
  }

  public boolean remove(Comment comment) {
    return target().removecomment );
  }

  public boolean remove(Element element) {
    return target().removeelement );
  }

  public boolean remove(ProcessingInstruction processingInstruction) {
    return target().removeprocessingInstruction );
  }

  public void normalize() {
    target().normalize();
  }

  private Element target() {
    return li.getElement();
  }
}