XMLFormat.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.xml;
 
import javolution.text.CharArray;
import javolution.text.TextBuilder;
import javolution.text.TextContext;
import javolution.text.TextFormat;
import javolution.xml.internal.stream.XMLStreamReaderImpl;
import javolution.xml.internal.stream.XMLStreamWriterImpl;
import javolution.xml.sax.Attributes;
import javolution.xml.stream.XMLStreamException;
import javolution.xml.stream.XMLStreamReader;
import javolution.xml.stream.XMLStreamWriter;
 
public abstract class XMLFormat<T> {
 
    private static final String NULL = "Null";
 
    protected XMLFormat() {}
 
    public boolean isReferenceable() {
        return true;
    }
 
    public T newInstance(Class<? extends T> cls, InputElement xml)
            throws XMLStreamException {
        try {
            return cls.newInstance();
        } catch (InstantiationException e) {
            throw new XMLStreamException(e);
        } catch (IllegalAccessException e) {
            throw new XMLStreamException(e);
        }
    }
 
    public abstract void write(T obj, OutputElement xml)
            throws XMLStreamException;
 
    public abstract void read(InputElement xml, T obj)
            throws XMLStreamException;
 
    @SuppressWarnings("unchecked")
    public static final class InputElement {
 
        final XMLStreamReaderImpl _reader = new XMLStreamReaderImpl();
 
        private XMLBinding _binding;
 
        private XMLReferenceResolver _referenceResolver;
 
        private boolean _isReaderAtNext;
 
        InputElement() {
            reset();
        }
 
        public XMLStreamReader getStreamReader() {
            return _reader;
        }
 
        public boolean hasNext() throws XMLStreamException {
            if (!_isReaderAtNext) {
                _isReaderAtNext = true;
                _reader.nextTag();
            }
            return _reader.getEventType() == XMLStreamReader.START_ELEMENT;
        }
 
        public <T> T getNext() throws XMLStreamException {
            if (!hasNext()) // Asserts isReaderAtNext == true
                throw new XMLStreamException("No more element to read",
                        _reader.getLocation());
 
            // Checks for null.
            if (_reader.getLocalName().equals(NULL)) {
                if (_reader.next() != XMLStreamReader.END_ELEMENT)
                    throw new XMLStreamException("Non Empty Null Element");
                _isReaderAtNext = false;
                return null;
            }
 
            Object ref = readReference();
            if (ref != null)
                return (T) ref;
 
            // Retrieves object's class from element tag.
            Class<?> cls = _binding.readClass(_reader, false);
            return readInstanceOf(cls);
        }
 
        public <T> T get(String name) throws XMLStreamException {
            if (!hasNext()// Asserts isReaderAtNext == true
                    || !_reader.getLocalName().equals(name))
                return null;
 
            Object ref = readReference();
            if (ref != null)
                return (T) ref;
 
            // Retrieves object's class from class attribute.
            Class<?> cls = _binding.readClass(_reader, true);
            return readInstanceOf(cls);
        }
 
        public <T> T get(String localName, String uri)
                throws XMLStreamException {
            if (uri == null)
                return (T) get(localName);
 
            if (!hasNext()// Asserts isReaderAtNext == true
                    || !_reader.getLocalName().equals(localName)
                    || !_reader.getNamespaceURI().equals(uri))
                return null;
 
            Object ref = readReference();
            if (ref != null)
                return (T) ref;
 
            // Retrieves object's class from class attribute.
            Class<?> cls = _binding.readClass(_reader, true);
            return readInstanceOf(cls);
        }
 
        public <T> T get(String name, Class<T> cls) throws XMLStreamException {
            if (!hasNext()// Asserts isReaderAtNext == true
                    || !_reader.getLocalName().equals(name))
                return null;
 
            Object ref = readReference();
            if (ref != null)
                return (T) ref;
 
            return readInstanceOf(cls);
        }
 
        public <T> T get(String localName, String uri, Class<T> cls)
                throws XMLStreamException {
            if (uri == null)
                return get(localName, cls);
 
            if (!hasNext()// Asserts isReaderAtNext == true
                    || !_reader.getLocalName().equals(localName)
                    || !_reader.getNamespaceURI().equals(uri))
                return null;
 
            Object ref = readReference();
            if (ref != null)
                return (T) ref;
 
            return readInstanceOf(cls);
        }
 
        // Returns the referenced object if any.
        private Object readReference() throws XMLStreamException {
            if (_referenceResolver == null)
                return null;
            Object ref = _referenceResolver.readReference(this);
            if (ref == null)
                return null;
            if (_reader.next() != XMLStreamReader.END_ELEMENT)
                throw new XMLStreamException("Non Empty Reference Element");
            _isReaderAtNext = false;
            return ref;
        }
 
        // Builds object of specified class.
        @SuppressWarnings("rawtypes")
        private <T> T readInstanceOf(Class cls) throws XMLStreamException {
 
            // Retrieves format.
            XMLFormat xmlFormat = _binding.getFormat(cls);
 
            // Creates object.
            _isReaderAtNext = false; // Makes attributes accessible.
            Object obj = xmlFormat.newInstance(cls, this);
 
            // Adds reference (before reading to support circular reference).
            if (_referenceResolver != null) {
                _referenceResolver.createReference(obj, this);
            }
 
            // Parses xml.
            xmlFormat.read(this, obj);
            if (hasNext()) // Asserts _isReaderAtNext == true
                throw new XMLStreamException("Incomplete element reading",
                        _reader.getLocation());
            _isReaderAtNext = false; // Skips end element.
            return (T) obj;
        }
 
        public CharArray getText() throws XMLStreamException {
            CharArray txt = _reader.getElementText();
            _isReaderAtNext = true; // End element is next.
            return txt;
        }
 
        public Attributes getAttributes() throws XMLStreamException {
            if (_isReaderAtNext)
                throw new XMLStreamException(
                        "Attributes should be read before content");
            return _reader.getAttributes();
        }
 
        public CharArray getAttribute(String name) throws XMLStreamException {
            if (_isReaderAtNext)
                throw new XMLStreamException(
                        "Attributes should be read before reading content");
            return _reader.getAttributeValue(null, name);
        }
 
        public String getAttribute(String name, String defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toString() : defaultValue;
        }
 
        public boolean getAttribute(String name, boolean defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toBoolean() : defaultValue;
        }
 
        public char getAttribute(String name, char defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            if (value == null)
                return defaultValue;
            if (value.length() != 1)
                throw new XMLStreamException(
                        "Single character expected (read '" + value + "')");
            return value.charAt(0);
        }
 
        public byte getAttribute(String name, byte defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? (byte) value.toInt() : defaultValue;
        }
 
        public short getAttribute(String name, short defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? (short) value.toInt() : defaultValue;
        }
 
        public int getAttribute(String name, int defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toInt() : defaultValue;
        }
 
        public long getAttribute(String name, long defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toLong() : defaultValue;
        }
 
        public float getAttribute(String name, float defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toFloat() : defaultValue;
        }
 
        public double getAttribute(String name, double defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            return (value != null) ? value.toDouble() : defaultValue;
        }
 
        public <T> T getAttribute(String name, T defaultValue)
                throws XMLStreamException {
            CharArray value = getAttribute(name);
            if (value == null)
                return defaultValue;
            // Parses attribute value.
            Class<?> type = defaultValue.getClass();
            TextFormat<?> format = TextContext.getFormat(type);
            if (format == null)
                throw new XMLStreamException("No TextFormat defined for "
                        + type);
            return (T) format.parse(value);
        }
 
        // Sets XML binding. 
        void setBinding(XMLBinding xmlBinding) {
            _binding = xmlBinding;
        }
 
        // Sets XML reference resolver. 
        void setReferenceResolver(XMLReferenceResolver xmlReferenceResolver) {
            _referenceResolver = xmlReferenceResolver;
        }
 
        // Resets for reuse.
        void reset() {
            _binding = XMLBinding.DEFAULT;
            _isReaderAtNext = false;
            _reader.reset();
            _referenceResolver = null;
        }
    }
 
    @SuppressWarnings("unchecked")
    public static final class OutputElement {
 
        final XMLStreamWriterImpl _writer = new XMLStreamWriterImpl();
 
        private XMLBinding _binding;
 
        private XMLReferenceResolver _referenceResolver;
 
        OutputElement() {
            reset();
        }
 
        public XMLStreamWriter getStreamWriter() {
            return _writer;
        }
 
        public void add(Object obj) throws XMLStreamException {
            if (obj == null) {
                _writer.writeEmptyElement(NULL);
                return;
            }
 
            // Writes start element.
            Class<?> cls = obj.getClass();
            _binding.writeClass(cls, _writer, false);
 
            // Checks if reference written.
            XMLFormat<Object> xmlFormat = (XMLFormat<Object>) _binding
                    .getFormat(cls);
            if (xmlFormat.isReferenceable() && writeReference(obj))
                return;
 
            xmlFormat.write(obj, this);
            _writer.writeEndElement();
        }
 
        public void add(Object obj, String name) throws XMLStreamException {
            if (obj == null)
                return;
 
            // Writes start element.
            _writer.writeStartElement(name);
 
            // Writes class attribute.
            Class<?> cls = obj.getClass();
            _binding.writeClass(cls, _writer, true);
 
            // Checks if reference written.
            XMLFormat<Object> xmlFormat = (XMLFormat<Object>) _binding
                    .getFormat(cls);
            if (xmlFormat.isReferenceable() && writeReference(obj))
                return;
 
            xmlFormat.write(obj, this);
            _writer.writeEndElement();
        }
 
        public void add(Object obj, String localName, String uri)
                throws XMLStreamException {
            if (obj == null)
                return;
 
            // Writes start element.
            _writer.writeStartElement(uri, localName);
 
            // Writes class attribute.
            Class<?> cls = obj.getClass();
            _binding.writeClass(cls, _writer, true);
 
            // Checks if reference written.
            XMLFormat<Object> xmlFormat = (XMLFormat<Object>) _binding
                    .getFormat(cls);
            if (xmlFormat.isReferenceable() && writeReference(obj))
                return;
 
            xmlFormat.write(obj, this);
            _writer.writeEndElement();
        }
 
        public <T> void add(T obj, String name, Class<T> cls)
                throws XMLStreamException {
            if (obj == null)
                return;
 
            // Writes start element.
            _writer.writeStartElement(name);
 
            // Checks if reference written.
            XMLFormat<T> xmlFormat = (XMLFormat<T>) _binding.getFormat(cls);
            if (xmlFormat.isReferenceable() && writeReference(obj))
                return;
 
            xmlFormat.write(obj, this);
            _writer.writeEndElement();
        }
 
        public <T> void add(T obj, String localName, String uri, Class<T> cls)
                throws XMLStreamException {
            if (obj == null)
                return;
 
            // Writes start element.
            _writer.writeStartElement(uri, localName);
 
            // Checks if reference written.
            XMLFormat<T> xmlFormat = (XMLFormat<T>) _binding.getFormat(cls);
            if (xmlFormat.isReferenceable() && writeReference(obj))
                return;
 
            xmlFormat.write(obj, this);
            _writer.writeEndElement();
        }
 
        // Returns true if reference written.
        private boolean writeReference(Object obj) throws XMLStreamException {
            if ((_referenceResolver == null)
                    || !_referenceResolver.writeReference(obj, this))
                return false;
            _writer.writeEndElement();
            return true; // Reference written.
        }
 
        public void addText(CharSequence text) throws XMLStreamException {
            _writer.writeCharacters(text);
        }
 
        public void addText(String text) throws XMLStreamException {
            _writer.writeCharacters(text);
        }
 
        public void setAttribute(String name, CharSequence value)
                throws XMLStreamException {
            if (value == null)
                return;
            _writer.writeAttribute(name, value);
        }
 
        public void setAttribute(String name, String value)
                throws XMLStreamException {
            if (value == null)
                return;
            _writer.writeAttribute(name, value);
        }
 
        public void setAttribute(String name, boolean value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        private TextBuilder _tmpTextBuilder = new TextBuilder();
 
        public void setAttribute(String name, char value)
                throws XMLStreamException {
            setAttribute(name,
                    (TextBuilder) _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, byte value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, short value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, int value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, long value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, float value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, double value)
                throws XMLStreamException {
            setAttribute(name, _tmpTextBuilder.clear().append(value));
        }
 
        public void setAttribute(String name, Object value)
                throws XMLStreamException {
            if (value == null)
                return;
            setAttribute(name, _tmpTextBuilder.clear().append(value.toString()));
        }
 
        // Sets XML binding. 
        void setBinding(XMLBinding xmlBinding) {
            _binding = xmlBinding;
        }
 
        // Sets XML reference resolver. 
        void setReferenceResolver(XMLReferenceResolver xmlReferenceResolver) {
            _referenceResolver = xmlReferenceResolver;
        }
 
        // Resets for reuse.
        void reset() {
            _binding = XMLBinding.DEFAULT;
            _writer.reset();
            _writer.setRepairingNamespaces(true);
            _writer.setAutomaticEmptyElements(true);
            _referenceResolver = null;
        }
    }
 
    public static class Default extends XMLFormat<Object> {
 
        public Default() {}
 
        @Override
        public boolean isReferenceable() {
            return false; // Always by value (immutable).
        }
 
        @Override
        public Object newInstance(Class<?> cls,
                javolution.xml.XMLFormat.InputElement xml)
                throws XMLStreamException {
            TextFormat<?> format = TextContext.getFormat(cls);
            if (format == null)
                throw new XMLStreamException(
                        "No TextFormat defined to parse instances of " + cls);
            CharArray value = xml.getAttribute("value");
            if (value == null)
                throw new XMLStreamException(
                        "Missing value attribute (to be able to parse the instance of "
                                + cls + ")");
            return format.parse(value);
        }
 
        public void read(XMLFormat.InputElement xml, Object obj)
                throws XMLStreamException {
            // Do nothing.
        }
 
        @SuppressWarnings("unchecked")
        public void write(Object obj, XMLFormat.OutputElement xml)
                throws XMLStreamException {
            TextBuilder tmp = new TextBuilder();
            TextFormat<?> tf = TextContext.getFormat(obj.getClass());
            ((TextFormat<Object>) tf).format(obj, tmp);
            xml.setAttribute("value", tmp);
        }
 
    };
}