1:
42: package ;
43:
44: import ;
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56: import ;
57: import ;
58: import ;
59: import ;
60:
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66: import ;
67: import ;
68: import ;
69: import ;
70: import ;
71: import ;
72: import ;
73: import ;
74: import ;
75: import ;
76: import ;
77:
78:
81: public abstract class RootXmlWriteHandler {
82:
83:
84: private SimpleObjectFactory classToHandlerMapping;
85:
86:
89: public RootXmlWriteHandler() {
90: this.classToHandlerMapping = new SimpleObjectFactory();
91:
92:
93: final MultiplexMappingEntry[] paintEntries = new MultiplexMappingEntry[2];
94: paintEntries[0] = new MultiplexMappingEntry("color", Color.class.getName());
95: paintEntries[1] = new MultiplexMappingEntry("gradientPaint", GradientPaint.class.getName());
96: addMultiplexMapping(Paint.class, "type", paintEntries);
97: addManualMapping(GradientPaint.class, GradientPaintWriteHandler.class);
98: addManualMapping(Color.class, ColorWriteHandler.class);
99:
100:
101: final MultiplexMappingEntry[] point2DEntries = new MultiplexMappingEntry[2];
102: point2DEntries[0] = new MultiplexMappingEntry("float", Point2D.Float.class.getName());
103: point2DEntries[1] = new MultiplexMappingEntry("double", Point2D.Double.class.getName());
104: addMultiplexMapping(Point2D.class, "type", point2DEntries);
105: addManualMapping(Point2D.Float.class, Point2DWriteHandler.class);
106: addManualMapping(Point2D.Double.class, Point2DWriteHandler.class);
107:
108:
109: final MultiplexMappingEntry[] strokeEntries = new MultiplexMappingEntry[1];
110: strokeEntries[0] = new MultiplexMappingEntry("basic", BasicStroke.class.getName());
111: addMultiplexMapping(Stroke.class, "type", strokeEntries);
112: addManualMapping(BasicStroke.class, BasicStrokeWriteHandler.class);
113:
114:
115: final MultiplexMappingEntry[] rectangle2DEntries = new MultiplexMappingEntry[2];
116: rectangle2DEntries[0] = new MultiplexMappingEntry(
117: "float", Rectangle2D.Float.class.getName()
118: );
119: rectangle2DEntries[1] = new MultiplexMappingEntry(
120: "double", Rectangle2D.Double.class.getName()
121: );
122: addMultiplexMapping(Rectangle2D.class, "type", rectangle2DEntries);
123: addManualMapping(Rectangle2D.Float.class, Rectangle2DWriteHandler.class);
124: addManualMapping(Rectangle2D.Double.class, Rectangle2DWriteHandler.class);
125:
126:
127: final MultiplexMappingEntry[] listEntries = new MultiplexMappingEntry[4];
128: listEntries[0] = new MultiplexMappingEntry("array-list", ArrayList.class.getName());
129: listEntries[1] = new MultiplexMappingEntry("linked-list", LinkedList.class.getName());
130: listEntries[2] = new MultiplexMappingEntry("vector", Vector.class.getName());
131: listEntries[3] = new MultiplexMappingEntry("stack", Stack.class.getName());
132: addMultiplexMapping(List.class, "type", listEntries);
133: addManualMapping(LinkedList.class, ListWriteHandler.class);
134: addManualMapping(Vector.class, ListWriteHandler.class);
135: addManualMapping(ArrayList.class, ListWriteHandler.class);
136: addManualMapping(Stack.class, ListWriteHandler.class);
137:
138:
139: addManualMapping(RenderingHints.class, RenderingHintsWriteHandler.class);
140: addManualMapping(Insets.class, InsetsWriteHandler.class);
141: addManualMapping(Font.class, FontWriteHandler.class);
142: }
143:
144:
149: protected abstract ObjectFactory getFactoryLoader();
150:
151:
161: protected void addManualMapping(final Class classToWrite, final Class handler) {
162: if (handler == null) {
163: throw new NullPointerException("handler must not be null.");
164: }
165: if (classToWrite == null) {
166: throw new NullPointerException("classToWrite must not be null.");
167: }
168: if (!XmlWriteHandler.class.isAssignableFrom(handler)) {
169: throw new IllegalArgumentException("The given handler is no XmlWriteHandler.");
170: }
171:
172: this.classToHandlerMapping.addManualMapping
173: (new ManualMappingDefinition(classToWrite, null, handler.getName()));
174: }
175:
176:
183: protected void addMultiplexMapping(final Class baseClass,
184: final String typeAttr,
185: final MultiplexMappingEntry[] mdef) {
186:
187: this.classToHandlerMapping.addMultiplexMapping(
188: new MultiplexMappingDefinition(baseClass, typeAttr, mdef)
189: );
190:
191: }
192:
193:
202: protected XmlWriteHandler getMapping(final Class classToWrite) throws XMLWriterException {
203:
204: if (classToWrite == null) {
205: throw new NullPointerException("ClassToWrite is null.");
206: }
207:
208:
209: ManualMappingDefinition manualMapping =
210: this.classToHandlerMapping.getManualMappingDefinition(classToWrite);
211: if (manualMapping == null) {
212:
213: manualMapping = getFactoryLoader().getManualMappingDefinition(classToWrite);
214: }
215: if (manualMapping != null) {
216: return loadHandlerClass(manualMapping.getWriteHandler());
217: }
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228: if (this.classToHandlerMapping.isGenericHandler(classToWrite)) {
229: return new GenericWriteHandler(
230: this.classToHandlerMapping.getFactoryForClass(classToWrite)
231: );
232: }
233: if (getFactoryLoader().isGenericHandler(classToWrite)) {
234: return new GenericWriteHandler(getFactoryLoader().getFactoryForClass(classToWrite));
235: }
236:
237: throw new XMLWriterException("Unable to handle " + classToWrite);
238: }
239:
240:
254: public void write(final String tagName, final Object object, final Class baseClass, final XMLWriter writer)
255: throws IOException, XMLWriterException {
256: if (object == null) {
257: return;
258: }
259: if (tagName == null) {
260: throw new NullPointerException("RootXmlWriteHandler.write(..) : tagName is null");
261: }
262: if (writer == null) {
263: throw new NullPointerException("RootXmlWriteHandler.write(..) : writer is null");
264: }
265: if (!baseClass.isInstance(object)) {
266: throw new ClassCastException("Object is no instance of " + baseClass);
267: }
268: final Class classToWrite = object.getClass();
269: final XmlWriteHandler handler = getMapping(classToWrite);
270: handler.setRootHandler(this);
271:
272: String attributeName = null;
273: String attributeValue = null;
274:
275:
276: MultiplexMappingDefinition mplex =
277: getFactoryLoader().getMultiplexDefinition(baseClass);
278: if (mplex == null) {
279: mplex = this.classToHandlerMapping.getMultiplexDefinition(baseClass);
280: }
281: if (mplex != null) {
282: final MultiplexMappingEntry entry =
283: mplex.getEntryForClass(classToWrite.getName());
284: if (entry != null) {
285: attributeName = mplex.getAttributeName();
286: attributeValue = entry.getAttributeValue();
287: }
288: else {
289: throw new XMLWriterException(
290: "Unable to find child mapping for multiplexer "
291: + baseClass + " to child " + classToWrite
292: );
293: }
294: }
295:
296: handler.write(tagName, object, writer, attributeName, attributeValue);
297: writer.allowLineBreak();
298: }
299:
300:
309: protected XmlWriteHandler loadHandlerClass(final String className)
310: throws XMLWriterException {
311: if (className == null) {
312: throw new XMLWriterException("LoadHanderClass: Class name not defined");
313: }
314: try {
315: final Class c = ObjectUtilities.getClassLoader(getClass()).loadClass(className);
316: return (XmlWriteHandler) c.newInstance();
317: }
318: catch (Exception e) {
319:
320: throw new XMLWriterException("LoadHanderClass: Unable to instantiate " + className, e);
321: }
322: }
323:
324: }