KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > dom4j > tree > AbstractProcessingInstruction


1 /*
2  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
3  *
4  * This software is open source.
5  * See the bottom of this file for the licence.
6  */

7
8 package org.dom4j.tree;
9
10 import java.io.IOException JavaDoc;
11 import java.io.Writer JavaDoc;
12 import java.util.HashMap JavaDoc;
13 import java.util.Iterator JavaDoc;
14 import java.util.Map JavaDoc;
15 import java.util.StringTokenizer JavaDoc;
16
17 import org.dom4j.Element;
18 import org.dom4j.ProcessingInstruction;
19 import org.dom4j.Visitor;
20
21 /**
22  * <p>
23  * <code>AbstractProcessingInstruction</code> is an abstract base class for
24  * tree implementors to use for implementation inheritence.
25  * </p>
26  *
27  * @author <a HREF="mailto:james.strachan@metastuff.com">James Strachan </a>
28  * @version $Revision: 1.17 $
29  */

30 public abstract class AbstractProcessingInstruction extends AbstractNode
31         implements ProcessingInstruction {
32     public AbstractProcessingInstruction() {
33     }
34
35     public short getNodeType() {
36         return PROCESSING_INSTRUCTION_NODE;
37     }
38
39     public String JavaDoc getPath(Element context) {
40         Element parent = getParent();
41
42         return ((parent != null) && (parent != context)) ? (parent
43                 .getPath(context) + "/processing-instruction()")
44                 : "processing-instruction()";
45     }
46
47     public String JavaDoc getUniquePath(Element context) {
48         Element parent = getParent();
49
50         return ((parent != null) && (parent != context)) ? (parent
51                 .getUniquePath(context) + "/processing-instruction()")
52                 : "processing-instruction()";
53     }
54
55     public String JavaDoc toString() {
56         return super.toString() + " [ProcessingInstruction: &" + getName()
57                 + ";]";
58     }
59
60     public String JavaDoc asXML() {
61         return "<?" + getName() + " " + getText() + "?>";
62     }
63
64     public void write(Writer JavaDoc writer) throws IOException JavaDoc {
65         writer.write("<?");
66         writer.write(getName());
67         writer.write(" ");
68         writer.write(getText());
69         writer.write("?>");
70     }
71
72     public void accept(Visitor visitor) {
73         visitor.visit(this);
74     }
75
76     public void setValue(String JavaDoc name, String JavaDoc value) {
77         throw new UnsupportedOperationException JavaDoc("This PI is read-only and "
78                 + "cannot be modified");
79     }
80
81     public void setValues(Map JavaDoc data) {
82         throw new UnsupportedOperationException JavaDoc("This PI is read-only and "
83                 + "cannot be modified");
84     }
85
86     public String JavaDoc getName() {
87         return getTarget();
88     }
89
90     public void setName(String JavaDoc name) {
91         setTarget(name);
92     }
93
94     public boolean removeValue(String JavaDoc name) {
95         return false;
96     }
97
98     // Helper methods
99

100     /**
101      * <p>
102      * This will convert the Map to a string representation.
103      * </p>
104      *
105      * @param values
106      * is a <code>Map</code> of PI data to convert
107      *
108      * @return DOCUMENT ME!
109      */

110     protected String JavaDoc toString(Map JavaDoc values) {
111         StringBuffer JavaDoc buffer = new StringBuffer JavaDoc();
112
113         for (Iterator JavaDoc iter = values.entrySet().iterator(); iter.hasNext();) {
114             Map.Entry JavaDoc entry = (Map.Entry JavaDoc) iter.next();
115             String JavaDoc name = (String JavaDoc) entry.getKey();
116             String JavaDoc value = (String JavaDoc) entry.getValue();
117
118             buffer.append(name);
119             buffer.append("=\"");
120             buffer.append(value);
121             buffer.append("\" ");
122         }
123
124         // remove the last space
125
buffer.setLength(buffer.length() - 1);
126
127         return buffer.toString();
128     }
129
130     /**
131      * <p>
132      * Parses the raw data of PI as a <code>Map</code>.
133      * </p>
134      *
135      * @param text
136      * <code>String</code> PI data to parse
137      *
138      * @return DOCUMENT ME!
139      */

140     protected Map JavaDoc parseValues(String JavaDoc text) {
141         Map JavaDoc data = new HashMap JavaDoc();
142
143         StringTokenizer JavaDoc s = new StringTokenizer JavaDoc(text, " =\'\"", true);
144
145         while (s.hasMoreTokens()) {
146             String JavaDoc name = getName(s);
147
148             if (s.hasMoreTokens()) {
149                 String JavaDoc value = getValue(s);
150                 data.put(name, value);
151             }
152         }
153
154         return data;
155     }
156
157     private String JavaDoc getName(StringTokenizer JavaDoc tokenizer) {
158         String JavaDoc token = tokenizer.nextToken();
159         StringBuffer JavaDoc name = new StringBuffer JavaDoc(token);
160
161         while (tokenizer.hasMoreTokens()) {
162             token = tokenizer.nextToken();
163
164             if (!token.equals("=")) {
165                 name.append(token);
166             } else {
167                 break;
168             }
169         }
170
171         return name.toString().trim();
172     }
173
174     private String JavaDoc getValue(StringTokenizer JavaDoc tokenizer) {
175         String JavaDoc token = tokenizer.nextToken();
176         StringBuffer JavaDoc value = new StringBuffer JavaDoc();
177
178         /* get the quote */
179         while (tokenizer.hasMoreTokens() && !token.equals("\'")
180                 && !token.equals("\"")) {
181             token = tokenizer.nextToken();
182         }
183
184         String JavaDoc quote = token;
185
186         while (tokenizer.hasMoreTokens()) {
187             token = tokenizer.nextToken();
188
189             if (!quote.equals(token)) {
190                 value.append(token);
191             } else {
192                 break;
193             }
194         }
195
196         return value.toString();
197     }
198 }
199
200 /*
201  * Redistribution and use of this software and associated documentation
202  * ("Software"), with or without modification, are permitted provided that the
203  * following conditions are met:
204  *
205  * 1. Redistributions of source code must retain copyright statements and
206  * notices. Redistributions must also contain a copy of this document.
207  *
208  * 2. Redistributions in binary form must reproduce the above copyright notice,
209  * this list of conditions and the following disclaimer in the documentation
210  * and/or other materials provided with the distribution.
211  *
212  * 3. The name "DOM4J" must not be used to endorse or promote products derived
213  * from this Software without prior written permission of MetaStuff, Ltd. For
214  * written permission, please contact dom4j-info@metastuff.com.
215  *
216  * 4. Products derived from this Software may not be called "DOM4J" nor may
217  * "DOM4J" appear in their names without prior written permission of MetaStuff,
218  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
219  *
220  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
221  *
222  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
223  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
224  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
225  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
226  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
227  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
228  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
229  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
230  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
231  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
232  * POSSIBILITY OF SUCH DAMAGE.
233  *
234  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
235  */

236
Popular Tags