New interface XMLizable (copied from Apache Excalibur) to mark classes that can serialize themselves to XML (SAX stream).

New interface ContentHandlerFactory (plus associated Factory with Service discovery) for sub-document parsing plug-ins. Used by the area tree but could be used independently.
ExtensionAttachments are now part of the area tree and are written by XMLRenderer and parsed by AreaTreeParser.
The PS Extensions are extended to support serialization to and deserialization from XML.
Added a test case that tests the PS Extension WRT the handling in the area tree XML.

git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@370452 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 224 insertions, 0 deletions

diff --git a/src/java/org/apache/fop/util/ContentHandlerFactory.java b/src/java/org/apache/fop/util/ContentHandlerFactory.java
new file mode 100644
index 000000000..da615cc54
--- /dev/null
+++ b/src/java/org/apache/fop/util/ContentHandlerFactory.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util;
+
+import org.xml.sax.ContentHandler;
+
+/**
+ * Factory interface implemented by classes that can instantiate ContentHandler subclasses which
+ * parse a SAX stream into Java objects.
+ */
+public interface ContentHandlerFactory {
+
+    /**
+     * @return an array of supported namespaces.
+     */
+    String[] getSupportedNamespaces();
+    
+    /**
+     * @return a new ContentHandler to handle a SAX stream
+     */
+    ContentHandler createContentHandler();
+    
+    /**
+     * Interface that ContentHandler implementations that parse Java objects from XML can implement
+     * to return these objects.
+     */
+    public interface ObjectSource {
+        
+        /**
+         * @return the object parsed from the SAX stream (call valid after parsing)
+         */
+        Object getObject();
+        
+    }
+    
+}
diff --git a/src/java/org/apache/fop/util/ContentHandlerFactoryRegistry.java b/src/java/org/apache/fop/util/ContentHandlerFactoryRegistry.java
new file mode 100644
index 000000000..68e215b45
--- /dev/null
+++ b/src/java/org/apache/fop/util/ContentHandlerFactoryRegistry.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.apache.fop.util.Service;
+
+/**
+ * This class holds references to various XML handlers used by FOP. It also
+ * supports automatic discovery of additional XML handlers available through
+ * the class path.
+ */
+public class ContentHandlerFactoryRegistry {
+
+    /** the logger */
+    private static Log log = LogFactory.getLog(ContentHandlerFactoryRegistry.class);
+    
+    private static ContentHandlerFactoryRegistry instance;
+    
+    /** Map from namespace URIs to ContentHandlerFactories */
+    private Map factories = new java.util.HashMap();
+    
+    /**
+     * @return a singleton instance of the ContentHandlerFactoryRegistry.
+     */
+    public static ContentHandlerFactoryRegistry getInstance() {
+        if (instance == null) {
+            instance = new ContentHandlerFactoryRegistry();
+        }
+        return instance;
+    }
+    
+    /**
+     * Default constructor.
+     */
+    public ContentHandlerFactoryRegistry() {
+        discover();
+    }
+    
+    /**
+     * Add an XML handler. The handler itself is inspected to find out what it supports.
+     * @param classname the fully qualified class name
+     */
+    public void addContentHandlerFactory(String classname) {
+        try {
+            ContentHandlerFactory factory 
+                = (ContentHandlerFactory)Class.forName(classname).newInstance();
+            addContentHandlerFactory(factory);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("Could not find "
+                                               + classname);
+        } catch (InstantiationException e) {
+            throw new IllegalArgumentException("Could not instantiate "
+                                               + classname);
+        } catch (IllegalAccessException e) {
+            throw new IllegalArgumentException("Could not access "
+                                               + classname);
+        } catch (ClassCastException e) {
+            throw new IllegalArgumentException(classname
+                                               + " is not an " 
+                                               + ContentHandlerFactory.class.getName());
+        }
+    }
+    
+    /**
+     * Add an ContentHandlerFactory. The instance is inspected to find out what it supports.
+     * @param factory the ContentHandlerFactory instance
+     */
+    public void addContentHandlerFactory(ContentHandlerFactory factory) {
+        String[] ns = factory.getSupportedNamespaces();
+        for (int i = 0; i < ns.length; i++) {
+            factories.put(ns[i], factory);
+        }
+    }
+    
+    /**
+     * Retrieves a ContentHandlerFactory instance of a given namespace URI.
+     * @param namespaceURI the namespace to be handled.
+     * @return the ContentHandlerFactory or null, if no suitable instance is available.
+     */
+    public ContentHandlerFactory getFactory(String namespaceURI) {
+        ContentHandlerFactory factory = (ContentHandlerFactory)factories.get(namespaceURI);
+        return factory;
+    }
+    
+    /**
+     * Discovers ContentHandlerFactory implementations through the classpath and dynamically
+     * registers them.
+     */
+    private void discover() {
+        // add mappings from available services
+        Iterator providers = Service.providers(ContentHandlerFactory.class);
+        if (providers != null) {
+            while (providers.hasNext()) {
+                String str = (String)providers.next();
+                try {
+                    if (log.isDebugEnabled()) {
+                        log.debug("Dynamically adding ContentHandlerFactory: " + str);
+                    }
+                    addContentHandlerFactory(str);
+                } catch (IllegalArgumentException e) {
+                    log.error("Error while adding ContentHandlerFactory", e);
+                }
+
+            }
+        }
+    }
+}
diff --git a/src/java/org/apache/fop/util/XMLizable.java b/src/java/org/apache/fop/util/XMLizable.java
new file mode 100644
index 000000000..ea02963ef
--- /dev/null
+++ b/src/java/org/apache/fop/util/XMLizable.java
@@ -0,0 +1,43 @@
+/* 
+ * Copyright 2002-2004 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.util;
+
+/* 
+ * Copied from Apache Excalibur:
+ * https://svn.apache.org/repos/asf/excalibur/trunk/components/xmlutil/
+ *                                           src/java/org/apache/excalibur/xml/sax/XMLizable.java
+ */
+
+import org.xml.sax.ContentHandler;
+import org.xml.sax.SAXException;
+
+/**
+ * This interface can be implemented by classes willing to provide an XML representation
+ * of their current state as SAX events.
+ */
+public interface XMLizable {
+    
+    /**
+     * Generates SAX events representing the object's state.
+     * @param handler ContentHandler instance to send the SAX events to
+     * @throws SAXException if there's a problem generating the SAX events
+     */
+    void toSAX(ContentHandler handler) throws SAXException;
+    
+}