001: // $Id: ElementWrapper.java 6601 2005-04-29 03:06:37Z oneovthafew $
002: package org.hibernate.tuple;
003:
004: import java.io.IOException;
005: import java.io.Serializable;
006: import java.io.Writer;
007: import java.util.Iterator;
008: import java.util.List;
009: import java.util.Map;
010:
011: import org.dom4j.Attribute;
012: import org.dom4j.Branch;
013: import org.dom4j.CDATA;
014: import org.dom4j.Comment;
015: import org.dom4j.Document;
016: import org.dom4j.Element;
017: import org.dom4j.Entity;
018: import org.dom4j.InvalidXPathException;
019: import org.dom4j.Namespace;
020: import org.dom4j.Node;
021: import org.dom4j.ProcessingInstruction;
022: import org.dom4j.QName;
023: import org.dom4j.Text;
024: import org.dom4j.Visitor;
025: import org.dom4j.XPath;
026:
027: /**
028: * Wraps dom4j elements, allowing them to exist in a
029: * non-hierarchical structure.
030: *
031: * @author Gavin King
032: */
033: public class ElementWrapper implements Element, Serializable {
034:
035: private Element element;
036: private Element parent;
037:
038: public Element getElement() {
039: return element;
040: }
041:
042: public ElementWrapper(Element element) {
043: this .element = element;
044: }
045:
046: public QName getQName() {
047: return element.getQName();
048: }
049:
050: public QName getQName(String s) {
051: return element.getQName(s);
052: }
053:
054: public void setQName(QName qName) {
055: element.setQName(qName);
056: }
057:
058: public Namespace getNamespace() {
059: return element.getNamespace();
060: }
061:
062: public Namespace getNamespaceForPrefix(String s) {
063: return element.getNamespaceForPrefix(s);
064: }
065:
066: public Namespace getNamespaceForURI(String s) {
067: return element.getNamespaceForURI(s);
068: }
069:
070: public List getNamespacesForURI(String s) {
071: return element.getNamespacesForURI(s);
072: }
073:
074: public String getNamespacePrefix() {
075: return element.getNamespacePrefix();
076: }
077:
078: public String getNamespaceURI() {
079: return element.getNamespaceURI();
080: }
081:
082: public String getQualifiedName() {
083: return element.getQualifiedName();
084: }
085:
086: public List additionalNamespaces() {
087: return element.additionalNamespaces();
088: }
089:
090: public List declaredNamespaces() {
091: return element.declaredNamespaces();
092: }
093:
094: public Element addAttribute(String attrName, String text) {
095: return element.addAttribute(attrName, text);
096: }
097:
098: public Element addAttribute(QName attrName, String text) {
099: return element.addAttribute(attrName, text);
100: }
101:
102: public Element addComment(String text) {
103: return element.addComment(text);
104: }
105:
106: public Element addCDATA(String text) {
107: return element.addCDATA(text);
108: }
109:
110: public Element addEntity(String name, String text) {
111: return element.addEntity(name, text);
112: }
113:
114: public Element addNamespace(String prefix, String uri) {
115: return element.addNamespace(prefix, uri);
116: }
117:
118: public Element addProcessingInstruction(String target, String text) {
119: return element.addProcessingInstruction(target, text);
120: }
121:
122: public Element addProcessingInstruction(String target, Map data) {
123: return element.addProcessingInstruction(target, data);
124: }
125:
126: public Element addText(String text) {
127: return element.addText(text);
128: }
129:
130: public void add(Attribute attribute) {
131: element.add(attribute);
132: }
133:
134: public void add(CDATA cdata) {
135: element.add(cdata);
136: }
137:
138: public void add(Entity entity) {
139: element.add(entity);
140: }
141:
142: public void add(Text text) {
143: element.add(text);
144: }
145:
146: public void add(Namespace namespace) {
147: element.add(namespace);
148: }
149:
150: public boolean remove(Attribute attribute) {
151: return element.remove(attribute);
152: }
153:
154: public boolean remove(CDATA cdata) {
155: return element.remove(cdata);
156: }
157:
158: public boolean remove(Entity entity) {
159: return element.remove(entity);
160: }
161:
162: public boolean remove(Namespace namespace) {
163: return element.remove(namespace);
164: }
165:
166: public boolean remove(Text text) {
167: return element.remove(text);
168: }
169:
170: public boolean supportsParent() {
171: return element.supportsParent();
172: }
173:
174: public Element getParent() {
175: return parent == null ? element.getParent() : parent;
176: }
177:
178: public void setParent(Element parent) {
179: element.setParent(parent);
180: this .parent = parent;
181: }
182:
183: public Document getDocument() {
184: return element.getDocument();
185: }
186:
187: public void setDocument(Document document) {
188: element.setDocument(document);
189: }
190:
191: public boolean isReadOnly() {
192: return element.isReadOnly();
193: }
194:
195: public boolean hasContent() {
196: return element.hasContent();
197: }
198:
199: public String getName() {
200: return element.getName();
201: }
202:
203: public void setName(String name) {
204: element.setName(name);
205: }
206:
207: public String getText() {
208: return element.getText();
209: }
210:
211: public void setText(String text) {
212: element.setText(text);
213: }
214:
215: public String getTextTrim() {
216: return element.getTextTrim();
217: }
218:
219: public String getStringValue() {
220: return element.getStringValue();
221: }
222:
223: public String getPath() {
224: return element.getPath();
225: }
226:
227: public String getPath(Element element) {
228: return element.getPath(element);
229: }
230:
231: public String getUniquePath() {
232: return element.getUniquePath();
233: }
234:
235: public String getUniquePath(Element element) {
236: return element.getUniquePath(element);
237: }
238:
239: public String asXML() {
240: return element.asXML();
241: }
242:
243: public void write(Writer writer) throws IOException {
244: element.write(writer);
245: }
246:
247: public short getNodeType() {
248: return element.getNodeType();
249: }
250:
251: public String getNodeTypeName() {
252: return element.getNodeTypeName();
253: }
254:
255: public Node detach() {
256: if (parent != null) {
257: parent.remove(this );
258: parent = null;
259: }
260: return element.detach();
261: }
262:
263: public List selectNodes(String xpath) {
264: return element.selectNodes(xpath);
265: }
266:
267: public Object selectObject(String xpath) {
268: return element.selectObject(xpath);
269: }
270:
271: public List selectNodes(String xpath, String comparison) {
272: return element.selectNodes(xpath, comparison);
273: }
274:
275: public List selectNodes(String xpath, String comparison,
276: boolean removeDups) {
277: return element.selectNodes(xpath, comparison, removeDups);
278: }
279:
280: public Node selectSingleNode(String xpath) {
281: return element.selectSingleNode(xpath);
282: }
283:
284: public String valueOf(String xpath) {
285: return element.valueOf(xpath);
286: }
287:
288: public Number numberValueOf(String xpath) {
289: return element.numberValueOf(xpath);
290: }
291:
292: public boolean matches(String xpath) {
293: return element.matches(xpath);
294: }
295:
296: public XPath createXPath(String xpath) throws InvalidXPathException {
297: return element.createXPath(xpath);
298: }
299:
300: public Node asXPathResult(Element element) {
301: return element.asXPathResult(element);
302: }
303:
304: public void accept(Visitor visitor) {
305: element.accept(visitor);
306: }
307:
308: public Object clone() {
309: return element.clone();
310: }
311:
312: public Object getData() {
313: return element.getData();
314: }
315:
316: public void setData(Object data) {
317: element.setData(data);
318: }
319:
320: public List attributes() {
321: return element.attributes();
322: }
323:
324: public void setAttributes(List list) {
325: element.setAttributes(list);
326: }
327:
328: public int attributeCount() {
329: return element.attributeCount();
330: }
331:
332: public Iterator attributeIterator() {
333: return element.attributeIterator();
334: }
335:
336: public Attribute attribute(int i) {
337: return element.attribute(i);
338: }
339:
340: public Attribute attribute(String name) {
341: return element.attribute(name);
342: }
343:
344: public Attribute attribute(QName qName) {
345: return element.attribute(qName);
346: }
347:
348: public String attributeValue(String name) {
349: return element.attributeValue(name);
350: }
351:
352: public String attributeValue(String name, String defaultValue) {
353: return element.attributeValue(name, defaultValue);
354: }
355:
356: public String attributeValue(QName qName) {
357: return element.attributeValue(qName);
358: }
359:
360: public String attributeValue(QName qName, String defaultValue) {
361: return element.attributeValue(qName, defaultValue);
362: }
363:
364: /**
365: * @deprecated
366: */
367: public void setAttributeValue(String name, String value) {
368: element.setAttributeValue(name, value);
369: }
370:
371: /**
372: * @deprecated
373: */
374: public void setAttributeValue(QName qName, String value) {
375: element.setAttributeValue(qName, value);
376: }
377:
378: public Element element(String name) {
379: return element.element(name);
380: }
381:
382: public Element element(QName qName) {
383: return element.element(qName);
384: }
385:
386: public List elements() {
387: return element.elements();
388: }
389:
390: public List elements(String name) {
391: return element.elements(name);
392: }
393:
394: public List elements(QName qName) {
395: return element.elements(qName);
396: }
397:
398: public Iterator elementIterator() {
399: return element.elementIterator();
400: }
401:
402: public Iterator elementIterator(String name) {
403: return element.elementIterator(name);
404:
405: }
406:
407: public Iterator elementIterator(QName qName) {
408: return element.elementIterator(qName);
409: }
410:
411: public boolean isRootElement() {
412: return element.isRootElement();
413: }
414:
415: public boolean hasMixedContent() {
416: return element.hasMixedContent();
417: }
418:
419: public boolean isTextOnly() {
420: return element.isTextOnly();
421: }
422:
423: public void appendAttributes(Element element) {
424: element.appendAttributes(element);
425: }
426:
427: public Element createCopy() {
428: return element.createCopy();
429: }
430:
431: public Element createCopy(String name) {
432: return element.createCopy(name);
433: }
434:
435: public Element createCopy(QName qName) {
436: return element.createCopy(qName);
437: }
438:
439: public String elementText(String name) {
440: return element.elementText(name);
441: }
442:
443: public String elementText(QName qName) {
444: return element.elementText(qName);
445: }
446:
447: public String elementTextTrim(String name) {
448: return element.elementTextTrim(name);
449: }
450:
451: public String elementTextTrim(QName qName) {
452: return element.elementTextTrim(qName);
453: }
454:
455: public Node getXPathResult(int i) {
456: return element.getXPathResult(i);
457: }
458:
459: public Node node(int i) {
460: return element.node(i);
461: }
462:
463: public int indexOf(Node node) {
464: return element.indexOf(node);
465: }
466:
467: public int nodeCount() {
468: return element.nodeCount();
469: }
470:
471: public Element elementByID(String id) {
472: return element.elementByID(id);
473: }
474:
475: public List content() {
476: return element.content();
477: }
478:
479: public Iterator nodeIterator() {
480: return element.nodeIterator();
481: }
482:
483: public void setContent(List list) {
484: element.setContent(list);
485: }
486:
487: public void appendContent(Branch branch) {
488: element.appendContent(branch);
489: }
490:
491: public void clearContent() {
492: element.clearContent();
493: }
494:
495: public List processingInstructions() {
496: return element.processingInstructions();
497: }
498:
499: public List processingInstructions(String name) {
500: return element.processingInstructions(name);
501: }
502:
503: public ProcessingInstruction processingInstruction(String name) {
504: return element.processingInstruction(name);
505: }
506:
507: public void setProcessingInstructions(List list) {
508: element.setProcessingInstructions(list);
509: }
510:
511: public Element addElement(String name) {
512: return element.addElement(name);
513: }
514:
515: public Element addElement(QName qName) {
516: return element.addElement(qName);
517: }
518:
519: public Element addElement(String name, String text) {
520: return element.addElement(name, text);
521:
522: }
523:
524: public boolean removeProcessingInstruction(String name) {
525: return element.removeProcessingInstruction(name);
526: }
527:
528: public void add(Node node) {
529: element.add(node);
530: }
531:
532: public void add(Comment comment) {
533: element.add(comment);
534: }
535:
536: public void add(Element element) {
537: element.add(element);
538: }
539:
540: public void add(ProcessingInstruction processingInstruction) {
541: element.add(processingInstruction);
542: }
543:
544: public boolean remove(Node node) {
545: return element.remove(node);
546: }
547:
548: public boolean remove(Comment comment) {
549: return element.remove(comment);
550: }
551:
552: public boolean remove(Element element) {
553: return element.remove(element);
554: }
555:
556: public boolean remove(ProcessingInstruction processingInstruction) {
557: return element.remove(processingInstruction);
558: }
559:
560: public void normalize() {
561: element.normalize();
562: }
563:
564: public boolean equals(Object other) {
565: return element.equals(other);
566: }
567:
568: public int hashCode() {
569: return element.hashCode();
570: }
571:
572: public String toString() {
573: return element.toString();
574: }
575:
576: }
|