KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > datatypes > util > xml > DataTypeXml


1 /*
2
3 This software is OSI Certified Open Source Software.
4 OSI Certified is a certification mark of the Open Source Initiative.
5
6 The license (Mozilla version 1.0) can be read at the MMBase site.
7 See http://www.MMBase.org/license
8
9 */

10 package org.mmbase.datatypes.util.xml;
11 import org.mmbase.datatypes.processors.*;
12 import java.util.*;
13 import org.w3c.dom.*;
14
15 import org.mmbase.bridge.Field;
16 import org.mmbase.bridge.util.Queries;
17 import org.mmbase.datatypes.*;
18 import org.mmbase.core.util.Fields;
19 import org.mmbase.util.*;
20 import org.mmbase.util.functions.Parameters;
21 import org.mmbase.util.xml.DocumentReader;
22 import org.mmbase.util.logging.*;
23 import org.mmbase.util.transformers.*;
24
25 /**
26  * Static methods used for parsing of datatypes.xml
27  *
28  * @author Michiel Meeuwissen
29  * @version $Id: DataTypeXml.java,v 1.5 2005/12/29 23:02:22 michiel Exp $
30  * @since MMBase-1.8
31  **/

32 public abstract class DataTypeXml {
33
34     private static final Logger log = Logging.getLoggerInstance(DataTypeXml.class);
35
36     /**
37      * Returns whether an element has a certain attribute, either an unqualified attribute or an attribute that fits in the
38      * default namespace
39      */

40     public static boolean hasAttribute(Element element, String JavaDoc localName) {
41         return DocumentReader.hasAttribute(element, DataTypeReader.NAMESPACE_DATATYPES, localName);
42     }
43
44     /**
45      * Returns the value of a certain attribute, either an unqualified attribute or an attribute that fits in the
46      * default namespace
47      */

48     protected static String JavaDoc getAttribute(Element element, String JavaDoc localName) {
49         return DocumentReader.getAttribute(element, DataTypeReader.NAMESPACE_DATATYPES, localName);
50     }
51
52
53     /**
54      * Reads a number of tags with 'xml:lang' attributes.
55      *
56      * @param tagName Wich tags to read. The bodies are the values.
57      * @param element From which element this tags must be childs.
58      * @param descriptions Existing LocalizedString instance or <code>null</code> if a new one must be created.
59      * @param defaultKey If the localized string was created with some silly automatic key, it can be provided here, in
60      * which case it will be changed if a tag withouth xml:lang is found, or with xml:lang equals the current default.
61      * It can also be <code>null</code>
62      * @return A new LocalizedString or the updated 'descriptions' parameter if that was not <code>null</code>
63      */

64
65     public static LocalizedString getLocalizedDescription(final String JavaDoc tagName, final Element element, LocalizedString descriptions, final String JavaDoc defaultKey) {
66         if (descriptions == null) descriptions = new LocalizedString(null);
67         descriptions.fillFromXml(tagName, element);
68         if (defaultKey != null && descriptions.getKey().equals(defaultKey)) {
69             descriptions.setKey(descriptions.get(LocalizedString.getDefault()));
70         }
71         return descriptions;
72     }
73
74
75
76     public static boolean getBooleanValue(Element element, boolean defaultValue) {
77         if (hasAttribute(element, "value")) {
78             return Boolean.valueOf(getAttribute(element, "value")).booleanValue();
79         } else {
80             return defaultValue;
81         }
82     }
83
84     public static Processor chainProcessors(Processor processor1, Processor processor2) {
85         Processor processor = processor1;
86         if (processor == null || processor instanceof CopyProcessor) {
87             processor = processor2;
88         } else if (processor2 instanceof CopyProcessor) {
89             processor = processor1;
90         } else if (processor instanceof ChainedProcessor) {
91             ((ChainedProcessor) processor).add(processor2);
92         } else {
93             ChainedProcessor chain = new ChainedProcessor();
94             chain.add(processor1);
95             chain.add(processor2);
96             processor = chain;
97         }
98         return processor;
99     }
100
101     public static CommitProcessor chainProcessors(CommitProcessor processor1, CommitProcessor processor2) {
102         CommitProcessor processor = processor1;
103         if (processor == null || processor instanceof EmptyCommitProcessor) {
104             processor = processor2;
105         } else if (processor2 instanceof EmptyCommitProcessor) {
106             processor = processor1;
107         } else if (processor instanceof ChainedCommitProcessor) {
108             ((ChainedCommitProcessor) processor).add(processor2);
109         } else {
110             ChainedCommitProcessor chain = new ChainedCommitProcessor();
111             chain.add(processor1);
112             chain.add(processor2);
113             processor = chain;
114         }
115         return processor;
116     }
117
118
119     private static Object JavaDoc getParameterValue(Element param) {
120         String JavaDoc stringValue = DocumentReader.getNodeTextValue(param);
121         NodeList childNodes = param.getChildNodes();
122         Collection subParams = null;
123         for (int i = 0; i < childNodes.getLength(); i++) {
124             Node child = childNodes.item(i);
125             if (! (child instanceof Element)) continue;
126             if (child.getLocalName().equals("param")) {
127                 Element subParam = (Element) child;
128                 if (subParams == null) subParams = new ArrayList();
129                 String JavaDoc name = subParam.getAttribute("name");
130                 subParams.add(new Entry(name, getParameterValue(subParam)));
131             }
132         }
133         if (subParams != null) {
134             if (! stringValue.equals("")) {
135                 log.warn("" + param + " has both a text value and sub parameters, ignoring the text value '" + stringValue + "'");
136             }
137             return subParams;
138         } else {
139             return stringValue;
140         }
141     }
142     private static void fillParameters(Element paramContainer, Parameters params) {
143         NodeList childNodes = paramContainer.getChildNodes();
144         for (int i = 0; i < childNodes.getLength(); i++) {
145             if (childNodes.item(i) instanceof Element) {
146                 Element paramElement = (Element) childNodes.item(i);
147                 if ("param".equals(paramElement.getLocalName())) {
148                     String JavaDoc name = paramElement.getAttribute("name");
149                     Object JavaDoc value = getParameterValue(paramElement);
150                     params.set(name, value);
151                 }
152             }
153         }
154     }
155
156     public static Processor createProcessor(Element processorElement) {
157         Processor processor = null;
158         NodeList childNodes = processorElement.getChildNodes();
159         for (int k = 0; k < childNodes.getLength(); k++) {
160             if (childNodes.item(k) instanceof Element) {
161                 Element classElement = (Element) childNodes.item(k);
162                 if ("class".equals(classElement.getLocalName())) {
163                     String JavaDoc clazString = classElement.getAttribute("name");
164                     if (clazString.equals("")) {
165                         log.warn("No 'name' attribute on " + org.mmbase.util.xml.XMLWriter.write(classElement, true) + ", trying body");
166                         clazString = DocumentReader.getNodeTextValue(classElement);
167                     }
168                     try {
169                         Class JavaDoc claz = Class.forName(clazString);
170                         Processor newProcessor;
171                         if (CharTransformer.class.isAssignableFrom(claz)) {
172                             CharTransformer charTransformer = Transformers.getCharTransformer(clazString, null, " valueintercepter ", false);
173                             if (charTransformer != null) {
174                                 newProcessor = new CharTransformerProcessor(charTransformer);
175                             } else {
176                                 continue;
177                             }
178                         } else if (Processor.class.isAssignableFrom(claz)) {
179                             newProcessor = (Processor)claz.newInstance();
180                         } else if (ParameterizedTransformerFactory.class.isAssignableFrom(claz)) {
181                             ParameterizedTransformerFactory factory = (ParameterizedTransformerFactory) claz.newInstance();
182                             Parameters params = factory.createParameters();
183                             fillParameters(classElement, params);
184                             Transformer transformer = factory.createTransformer(params);
185                             newProcessor = new CharTransformerProcessor((CharTransformer) transformer);
186                         } else if (ParameterizedProcessorFactory.class.isAssignableFrom(claz)) {
187                             ParameterizedProcessorFactory factory = (ParameterizedProcessorFactory) claz.newInstance();
188                             Parameters params = factory.createParameters();
189                             fillParameters(classElement, params);
190                             newProcessor = factory.createProcessor(params);
191                         } else {
192                             log.error("Found class " + clazString + " is not a Processor or a CharTransformer, nor a factory for those.");
193                             continue;
194                         }
195                         processor = chainProcessors(processor, newProcessor);
196                     } catch (ClassNotFoundException JavaDoc cnfe) {
197                         log.error("Class '" + clazString + "' could not be found");
198                     } catch (IllegalAccessException JavaDoc iae) {
199                         log.error("Class " + clazString + " may not be instantiated");
200                     } catch (InstantiationException JavaDoc ie) {
201                         log.error("Class " + clazString + " can not be instantiated");
202                     }
203
204                 }
205             }
206         }
207         return processor == null ? CopyProcessor.getInstance() : processor;
208     }
209     public static CommitProcessor createCommitProcessor(Element processorElement) {
210         CommitProcessor processor = null;
211         NodeList childNodes = processorElement.getChildNodes();
212         for (int k = 0; k < childNodes.getLength(); k++) {
213             if (childNodes.item(k) instanceof Element) {
214                 Element classElement = (Element) childNodes.item(k);
215                 if ("class".equals(classElement.getLocalName())) {
216                     String JavaDoc clazString = classElement.getAttribute("name");
217                     if (clazString.equals("")) {
218                         log.warn("No 'name' attribute on " + org.mmbase.util.xml.XMLWriter.write(classElement, true) + ", trying body");
219                         clazString = DocumentReader.getNodeTextValue(classElement);
220                     }
221                     try {
222                         Class JavaDoc claz = Class.forName(clazString);
223                         CommitProcessor newProcessor;
224                         if (CommitProcessor.class.isAssignableFrom(claz)) {
225                             newProcessor = (CommitProcessor)claz.newInstance();
226                         } else if (ParameterizedCommitProcessorFactory.class.isAssignableFrom(claz)) {
227                             ParameterizedCommitProcessorFactory factory = (ParameterizedCommitProcessorFactory) claz.newInstance();
228                             Parameters params = factory.createParameters();
229                             fillParameters(classElement, params);
230                             newProcessor = factory.createProcessor(params);
231                         } else {
232                             log.error("Found class " + clazString + " is not a CommitProcessor or a factory for that.");
233                             continue;
234                         }
235                         processor = chainProcessors(processor, newProcessor);
236                     } catch (ClassNotFoundException JavaDoc cnfe) {
237                         log.error("Class '" + clazString + "' could not be found");
238                     } catch (IllegalAccessException JavaDoc iae) {
239                         log.error("Class " + clazString + " may not be instantiated");
240                     } catch (InstantiationException JavaDoc ie) {
241                         log.error("Class " + clazString + " can not be instantiated");
242                     }
243
244                 }
245             }
246         }
247         return processor == null ? EmptyCommitProcessor.getInstance() : processor;
248     }
249
250
251     public static String JavaDoc getValue(Element element) {
252         if (hasAttribute(element, "value")) {
253             return getAttribute(element, "value");
254         } else {
255             throw new IllegalArgumentException JavaDoc("no 'value' argument");
256         }
257     }
258
259     public static long getLongValue(Element element) {
260         if (hasAttribute(element, "value")) {
261             return Long.parseLong(getAttribute(element, "value"));
262         } else {
263             throw new IllegalArgumentException JavaDoc("no 'value' argument");
264         }
265     }
266 }
267
268
Popular Tags