001: /*
002: * $Id: ProxyElementAdapter.java 471756 2006-11-06 15:01:43Z husted $
003: *
004: * Licensed to the Apache Software Foundation (ASF) under one
005: * or more contributor license agreements. See the NOTICE file
006: * distributed with this work for additional information
007: * regarding copyright ownership. The ASF licenses this file
008: * to you under the Apache License, Version 2.0 (the
009: * "License"); you may not use this file except in compliance
010: * with the License. You may obtain a copy of the License at
011: *
012: * http://www.apache.org/licenses/LICENSE-2.0
013: *
014: * Unless required by applicable law or agreed to in writing,
015: * software distributed under the License is distributed on an
016: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017: * KIND, either express or implied. See the License for the
018: * specific language governing permissions and limitations
019: * under the License.
020: */
021: package org.apache.struts2.views.xslt;
022:
023: import java.util.ArrayList;
024: import java.util.List;
025:
026: import org.apache.commons.logging.Log;
027: import org.apache.commons.logging.LogFactory;
028: import org.w3c.dom.Attr;
029: import org.w3c.dom.DOMException;
030: import org.w3c.dom.Element;
031: import org.w3c.dom.Node;
032: import org.w3c.dom.NodeList;
033: import org.w3c.dom.TypeInfo;
034:
035: /**
036: * ProxyElementAdapter is a pass-through adapter for objects which already
037: * implement the Element interface. All methods are proxied to the underlying
038: * Node except getParent(), getNextSibling() and getPreviousSibling(), which
039: * are implemented by the abstract adapter node to work with the parent adapter.
040: *
041: * Note: this class wants to be (extend) both an AbstractElementAdapter
042: * and ProxyElementAdapter, but its proxy-ness is winning right now.
043: */
044: public class ProxyElementAdapter extends ProxyNodeAdapter implements
045: Element {
046:
047: private Log log = LogFactory.getLog(this .getClass());
048:
049: public ProxyElementAdapter(AdapterFactory factory,
050: AdapterNode parent, Element value) {
051: super (factory, parent, value);
052: }
053:
054: /**
055: * Get the proxied Element
056: */
057: protected Element element() {
058: return (Element) getPropertyValue();
059: }
060:
061: protected List<Node> buildChildAdapters() {
062: List<Node> adapters = new ArrayList<Node>();
063: NodeList children = node().getChildNodes();
064: for (int i = 0; i < children.getLength(); i++) {
065: Node child = children.item(i);
066: Node adapter = wrap(child);
067: if (adapter != null) {
068: log.debug("wrapped child node: " + child.getNodeName());
069: adapters.add(adapter);
070: }
071: }
072: return adapters;
073: }
074:
075: // Proxied Element methods
076:
077: public String getTagName() {
078: return element().getTagName();
079: }
080:
081: public boolean hasAttribute(String name) {
082: return element().hasAttribute(name);
083: }
084:
085: public String getAttribute(String name) {
086: return element().getAttribute(name);
087: }
088:
089: public boolean hasAttributeNS(String namespaceURI, String localName) {
090: return element().hasAttributeNS(namespaceURI, localName);
091: }
092:
093: public Attr getAttributeNode(String name) {
094: log.debug("wrapping attribute");
095: return (Attr) wrap(element().getAttributeNode(name));
096: }
097:
098: // I'm overriding this just for clarity. The base impl is correct.
099: public NodeList getElementsByTagName(String name) {
100: return super .getElementsByTagName(name);
101: }
102:
103: public String getAttributeNS(String namespaceURI, String localName) {
104: return element().getAttributeNS(namespaceURI, localName);
105: }
106:
107: public Attr getAttributeNodeNS(String namespaceURI, String localName) {
108: return (Attr) wrap(element().getAttributeNodeNS(namespaceURI,
109: localName));
110: }
111:
112: public NodeList getElementsByTagNameNS(String namespaceURI,
113: String localName) {
114: return super .getElementsByTagNameNS(namespaceURI, localName);
115: }
116:
117: // Unsupported mutators of Element
118:
119: public void removeAttribute(String name) throws DOMException {
120: throw new UnsupportedOperationException();
121: }
122:
123: public void removeAttributeNS(String namespaceURI, String localName)
124: throws DOMException {
125: throw new UnsupportedOperationException();
126: }
127:
128: public void setAttribute(String name, String value)
129: throws DOMException {
130: throw new UnsupportedOperationException();
131: }
132:
133: public Attr removeAttributeNode(Attr oldAttr) throws DOMException {
134: throw new UnsupportedOperationException();
135: }
136:
137: public Attr setAttributeNode(Attr newAttr) throws DOMException {
138: throw new UnsupportedOperationException();
139: }
140:
141: public Attr setAttributeNodeNS(Attr newAttr) throws DOMException {
142: throw new UnsupportedOperationException();
143: }
144:
145: public void setAttributeNS(String namespaceURI,
146: String qualifiedName, String value) throws DOMException {
147: throw new UnsupportedOperationException();
148: }
149:
150: // end proxied Element methods
151:
152: // unsupported DOM level 3 methods
153:
154: public TypeInfo getSchemaTypeInfo() {
155: throw operationNotSupported();
156: }
157:
158: public void setIdAttribute(String string, boolean b)
159: throws DOMException {
160: throw operationNotSupported();
161: }
162:
163: public void setIdAttributeNS(String string, String string1,
164: boolean b) throws DOMException {
165: throw operationNotSupported();
166: }
167:
168: public void setIdAttributeNode(Attr attr, boolean b)
169: throws DOMException {
170: throw operationNotSupported();
171: }
172:
173: // end DOM level 3 methods
174:
175: public String toString() {
176: return "ProxyElement for: " + element();
177: }
178: }
|