source: DCWoRMS/trunk/src/simulator/utils/GSSimXML.java @ 477

package simulator.utils;

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;

import org.castor.mapping.BindingType;
import org.exolab.castor.xml.ClassDescriptorResolverFactory;
import org.exolab.castor.xml.Introspector;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.Marshaller;
import org.exolab.castor.xml.Unmarshaller;
import org.exolab.castor.xml.ValidationException;
import org.exolab.castor.xml.XMLClassDescriptorResolver;

/**
 * This class provides static methods for marshalling and unmarshalling xml documents.
 * It uses static cache objects, making the marshalling and unmarshalling process far quicker. 
 * 
 * @author Stanislaw Szczepanowski
 * @see <a href="http://www.castor.org/xml-best-practice.html#Performance-Considerations">Castor - Performance Considerations</a>
 */
public class GSSimXML {

        /**
         * Hidden constructor
         */
        protected GSSimXML() {
        }
        
        /** The class descriptor resolver */
        protected static XMLClassDescriptorResolver mcdr = (XMLClassDescriptorResolver) ClassDescriptorResolverFactory.createClassDescriptorResolver(BindingType.XML);
        
        /** The unmarshaller object */
        protected static Unmarshaller unmarshaller = new Unmarshaller();
        
        /** The marshaller object */
        protected static Marshaller marshaller = new Marshaller();
        
        //static initialization
        static {
                mcdr.setIntrospector(new Introspector());
                unmarshaller.setResolver(mcdr);
                marshaller.setResolver(mcdr);
        }
        
        /**
         * A generic method for marshalling.
         * @param <T> the type of the object that is to be marshalled
         * @param object the object that is to be marshalled
         * @param writer the writer, where the result is to be written to
         * @return true, if the operation succeeded; false otherwise
         */
        public static synchronized <T> boolean marshal(T object, Writer writer) {
                try {
                        marshaller.setWriter(writer);
                        marshaller.marshal(object);
                } catch (IOException e) {
                        e.printStackTrace();
                        return false;
                } catch (MarshalException e) {
                        e.printStackTrace();
                        return false;
                } catch (ValidationException e) {
                        e.printStackTrace();
                        return false;
                }
                return true;
        }
        
        /**
         * A generic method for marshalling.
         * Performs a marshalling and return the result in form of a {@link String} object.
         * @param <T> the type of the object that is to be marshalled
         * @param object the object that is to be marshalled
         * @return a string containing the marshalled xml or <code>null</code> if any error occurred
         */
        public static synchronized <T> String marshal(T object) {
                StringWriter sw = new StringWriter();
                if (marshal(object, sw))
                        return sw.toString();
                else 
                        return null;
        }

        /**
         * A generic method for unmarshalling.
         * @param <T> the type of the object that is to be unmarshalled
         * @param clazz the class of the object that is to be marshalled
         * @param reader the reader, from which the result is to be read
         * @return the unmarshalled object; <code>null</code> if error occurs
         */
        public static synchronized <T> T unmarshal(Class<T> clazz, Reader reader) {
                unmarshaller.setClass(clazz);
                T result = null;
                try {
                        result = (T) unmarshaller.unmarshal(reader);
                } catch (MarshalException e) {
                        e.printStackTrace();
                        return null;
                } catch (ValidationException e) {
                        e.printStackTrace();
                        return null;
                }
                return result;
        }
        
        /**
         * A generic method for unmarshalling.
         * @param <T> the type of the object that is to be unmarshalled
         * @param clazz the class of the object that is to be marshalled
         * @param xml the string, containing an xml document, from which the result is to be read
         * @return the unmarshalled object; <code>null</code> if error occurs
         */
        public static synchronized <T> T unmarshal(Class<T> clazz, String xml) {
                return unmarshal(clazz, new StringReader(xml));
        }
}