|
1
18 package org.enhydra.barracuda.contrib.sam.xmlform.dtd;
19
20 import java.io.File  ;
22 import java.io.FileReader ;
23 import java.io.FileWriter ;
24 import java.io.InputStream ;
25 import java.io.InputStreamReader ;
26 import java.io.IOException ;
27 import java.io.OutputStream ;
28 import java.io.OutputStreamWriter ;
29 import java.io.Reader ;
30 import java.io.Writer ;
31 import java.util.HashMap ;
32 import java.util.Iterator ;
33 import java.util.Map ;
34 import org.xml.sax.EntityResolver ;
35 import org.xml.sax.ErrorHandler ;
36 import org.xml.sax.InputSource ;
37 import org.xml.sax.Locator ;
38 import org.xml.sax.SAXException ;
39 import org.xml.sax.SAXParseException ;
40 import org.xml.sax.XMLReader ;
41 import org.xml.sax.ext.LexicalHandler ;
42 import org.xml.sax.helpers.DefaultHandler ;
43 import org.xml.sax.helpers.XMLReaderFactory ;
44
45 import java.util.Iterator ;
47 import java.util.List ;
48 import java.util.LinkedList ;
49
50 public class RadioImpl extends DefaultHandler implements Cloneable , Unmarshallable, LexicalHandler , Radio {
51
52 private List optionList;
53
54
55 private String docTypeString;
56
57
58 private String outputEncoding;
59
60
61 private Unmarshallable zeus_currentUNode;
62
63
64 private Unmarshallable zeus_parentUNode;
65
66
67 private boolean zeus_thisNodeHandled = false;
68
69
70 private boolean hasDTD;
71
72
73 private boolean validate;
74
75
76 private Map namespaceMappings;
77
78
79 private static EntityResolver entityResolver;
80
81
82 private static ErrorHandler errorHandler;
83
84 private static RadioImpl prototype = null;
85
86 public static void setPrototype(RadioImpl prototype) {
87 RadioImpl.prototype = prototype;
88 }
89 public static RadioImpl newInstance() {
90 try {
91 return (prototype!=null)?(RadioImpl)prototype.clone(): new RadioImpl();
92 } catch (CloneNotSupportedException e) {
93 return null; }
95 }
96 public RadioImpl() {
97 optionList = new LinkedList ();
98 docTypeString = "";
99 hasDTD = false;
100 validate = false;
101 namespaceMappings = new HashMap ();
102 }
103
104 public List getOptionList() {
105 return optionList;
106 }
107
108 public void setOptionList(List optionList) {
109 this.optionList = optionList;
110 }
111
112 public void addOption(Option option) {
113 optionList.add(option);
114 }
115
116 public void removeOption(Option option) {
117 optionList.remove(option);
118 }
119
120 public void setDocType(String name, String publicID, String systemID) {
121 try {
122 startDTD(name, publicID, systemID);
123 } catch (SAXException neverHappens) { }
124 }
125
126 public void setOutputEncoding(String outputEncoding) {
127 this.outputEncoding = outputEncoding;
128 }
129
130 public void marshal(File file) throws IOException {
131 marshal(new FileWriter (file));
133 }
134
135 public void marshal(OutputStream outputStream) throws IOException {
136 marshal(new OutputStreamWriter (outputStream));
138 }
139
140 public void marshal(Writer writer) throws IOException {
141 writer.write("<?xml version=\"1.0\" ");
143 if (outputEncoding != null) {
144 writer.write("encoding=\"");
145 writer.write(outputEncoding);
146 writer.write("\"?>\n\n");
147
148 } else {
149 writer.write("encoding=\"UTF-8\"?>\n\n");
150
151 }
152 writer.write(docTypeString);
154 writer.write("\n");
155 writeXMLRepresentation(writer, "");
157
158 writer.flush();
160 writer.close();
161 }
162
163 protected void writeXMLRepresentation(Writer writer,
164 String indent)
165 throws IOException {
166
167 writer.write(indent);
168 writer.write("<radio");
169
170 for (Iterator i = namespaceMappings.keySet().iterator(); i.hasNext(); ) {
172 String prefix = (String )i.next();
173 String uri = (String )namespaceMappings.get(prefix);
174 writer.write(" xmlns");
175 if (!prefix.trim().equals("")) {
176 writer.write(":");
177 writer.write(prefix);
178 }
179 writer.write("=\"");
180 writer.write(uri);
181 writer.write("\"\n ");
182 }
183
184 writer.write(">");
186 writer.write("\n");
187
188 for (Iterator i=optionList.iterator(); i.hasNext(); ) {
190 OptionImpl option = (OptionImpl)i.next();
191 option.writeXMLRepresentation(writer,
192 new StringBuffer (indent).append(" ").toString());
193 }
194 writer.write(indent);
195 writer.write("</radio>\n");
196 }
197
198 private String escapeAttributeValue(String attributeValue) {
199 String returnValue = attributeValue;
200 for (int i = 0; i < returnValue.length(); i++) {
201 char ch = returnValue.charAt(i);
202 if (ch == '"') {
203 returnValue = new StringBuffer ()
204 .append(returnValue.substring(0, i))
205 .append(""")
206 .append(returnValue.substring(i+1))
207 .toString();
208 }
209 }
210 return returnValue;
211 }
212
213 private String escapeTextValue(String textValue) {
214 String returnValue = textValue;
215 for (int i = 0; i < returnValue.length(); i++) {
216 char ch = returnValue.charAt(i);
217 if (ch == '<') {
218 returnValue = new StringBuffer ()
219 .append(returnValue.substring(0, i))
220 .append("<")
221 .append(returnValue.substring(i+1))
222 .toString();
223 } else if (ch == '>') {
224 returnValue = new StringBuffer ()
225 .append(returnValue.substring(0, i))
226 .append(">")
227 .append(returnValue.substring(i+1))
228 .toString();
229 }
230 }
231 return returnValue;
232 }
233
234
241 public static void setEntityResolver(EntityResolver resolver) {
242 entityResolver = resolver;
243 }
244
245
252 public static void setErrorHandler(ErrorHandler handler) {
253 errorHandler = handler;
254 }
255
256 public static Radio unmarshal(File file) throws IOException {
257 return unmarshal(new FileReader (file));
259 }
260
261 public static Radio unmarshal(File file, boolean validate) throws IOException {
262 return unmarshal(new FileReader (file), validate);
264 }
265
266 public static Radio unmarshal(InputStream inputStream) throws IOException {
267 return unmarshal(new InputStreamReader (inputStream));
269 }
270
271 public static Radio unmarshal(InputStream inputStream, boolean validate) throws IOException {
272 return unmarshal(new InputStreamReader (inputStream), validate);
274 }
275
276 public static Radio unmarshal(Reader reader) throws IOException {
277 return unmarshal(reader, false);
279 }
280
281 public static Radio unmarshal(Reader reader, boolean validate) throws IOException {
282 RadioImpl radio = RadioImpl.newInstance();
283 radio.setValidating(validate);
284 radio.setCurrentUNode(radio);
285 radio.setParentUNode(null);
286 XMLReader parser = null;
288 String parserClass = System.getProperty("org.xml.sax.driver",
289 "org.apache.xerces.parsers.SAXParser");
290 try {
291 parser = XMLReaderFactory.createXMLReader(parserClass);
292
293 if (entityResolver != null) {
295 parser.setEntityResolver(entityResolver);
296 }
297
298 parser.setErrorHandler(radio);
300
301 parser.setProperty("http://xml.org/sax/properties/lexical-handler", radio);
303
304 parser.setContentHandler(radio);
306 } catch (SAXException e) {
307 throw new IOException ("Could not load XML parser: " +
308 e.getMessage());
309 }
310
311 InputSource inputSource = new InputSource (reader);
312 try {
313 parser.setFeature("http://xml.org/sax/features/validation", new Boolean (validate).booleanValue());
314 parser.setFeature("http://xml.org/sax/features/namespaces", true);
315 parser.setFeature("http://xml.org/sax/features/namespace-prefixes", false);
316 parser.parse(inputSource);
317 } catch (SAXException e) {
318 throw new IOException ("Error parsing XML document: " +
319 e.getMessage());
320 }
321
322 return radio;
324 }
325
326 public Unmarshallable getParentUNode() {
327 return zeus_parentUNode;
328 }
329
330 public void setParentUNode(Unmarshallable parentUNode) {
331 this.zeus_parentUNode = parentUNode;
332 }
333
334 public Unmarshallable getCurrentUNode() {
335 return zeus_currentUNode;
336 }
337
338 public void setCurrentUNode(Unmarshallable currentUNode) {
339 this.zeus_currentUNode = currentUNode;
340 }
341
342 public void setValidating(boolean validate) {
343 this.validate = validate;
344 }
345
346 public void startDocument() throws SAXException {
347 }
349
350 public void setDocumentLocator(Locator locator) {
351 }
353
354 public void startPrefixMapping(String prefix, String uri)
355 throws SAXException {
356 namespaceMappings.put(prefix, uri);
357 }
358
359 public void startElement(String namespaceURI, String localName,
360 String qName, org.xml.sax.Attributes atts)
361 throws SAXException {
362
363 Unmarshallable current = getCurrentUNode();
365 if (current != this) {
366 current.startElement(namespaceURI, localName, qName, atts);
367 return;
368 }
369
370 if ((localName.equals("radio")) && (!zeus_thisNodeHandled)) {
372 for (int i=0, len=atts.getLength(); i<len; i++) {
374 String attName= atts.getLocalName(i);
375 String attValue = atts.getValue(i);
376 }
377 zeus_thisNodeHandled = true;
378 return;
379 } else {
380 if (localName.equals("option")) {
382 OptionImpl option = OptionImpl.newInstance();
383 current = getCurrentUNode();
384 option.setParentUNode(current);
385 option.setCurrentUNode(option);
386 this.setCurrentUNode(option);
387 option.startElement(namespaceURI, localName, qName, atts);
388 optionList.add(option);
390 return;
391 }
392 }
393 }
394
395 public void endElement(String namespaceURI, String localName,
396 String qName)
397 throws SAXException {
398
399 Unmarshallable current = getCurrentUNode();
400 if (current != this) {
401 current.endElement(namespaceURI, localName, qName);
402 return;
403 }
404
405 Unmarshallable parent = getCurrentUNode().getParentUNode();
406 if (parent != null) {
407 parent.setCurrentUNode(parent);
408 }
409 }
410
411 public void characters(char[] ch, int start, int len)
412 throws SAXException {
413
414 Unmarshallable current = getCurrentUNode();
416 if (current != this) {
417 current.characters(ch, start, len);
418 return;
419 }
420
421 String text = new String (ch, start, len);
422 text = text.trim();
423 }
424
425 public void comment(char ch[], int start, int len) throws SAXException {
426 }
428
429 public void warning(SAXParseException e) throws SAXException {
430 if (errorHandler != null) {
431 errorHandler.warning(e);
432 }
433 }
434
435 public void error(SAXParseException e) throws SAXException {
436 if ((validate) && (!hasDTD)) {
437 throw new SAXException ("Validation is turned on, but no DTD has been specified in the input XML document. Please supply a DTD through a DOCTYPE reference.");
438 }
439 if (errorHandler != null) {
440 errorHandler.error(e);
441 }
442 }
443
444 public void fatalError(SAXParseException e) throws SAXException {
445 if ((validate) && (!hasDTD)) {
446 throw new SAXException ("Validation is turned on, but no DTD has been specified in the input XML document. Please supply a DTD through a DOCTYPE reference.");
447 }
448 if (errorHandler != null) {
449 errorHandler.fatalError(e);
450 }
451 }
452
453 public void startDTD(String name, String publicID, String systemID)
454 throws SAXException {
455
456 if ((name == null) || (name.equals(""))) {
457 docTypeString = "";
458 return;
459 }
460
461 hasDTD = true;
462 StringBuffer docTypeSB = new StringBuffer ();
463 boolean hasPublic = false;
464
465 docTypeSB.append("<!DOCTYPE ")
466 .append(name);
467
468 if ((publicID != null) && (!publicID.equals(""))) {
469 docTypeSB.append(" PUBLIC \"")
470 .append(publicID)
471 .append("\"");
472 hasPublic = true;
473 }
474
475 if ((systemID != null) && (!systemID.equals(""))) {
476 if (!hasPublic) {
477 docTypeSB.append(" SYSTEM");
478 }
479 docTypeSB.append(" \"")
480 .append(systemID)
481 .append("\"");
482
483 }
484
485 docTypeSB.append(">");
486
487 docTypeString = docTypeSB.toString();
488 }
489
490 public void endDTD() throws SAXException {
491 }
493
494 public void startEntity(String name) throws SAXException {
495 }
497
498 public void endEntity(String name) throws SAXException {
499 }
501
502 public void startCDATA() throws SAXException {
503 }
505
506 public void endCDATA() throws SAXException {
507 }
509
510 }
511 |
Popular Tags |
Java API By Example, From Geeks To Geeks.