| /* |
| * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Denise Smith - 2.6 - initial implementation |
| // Radek Felman - 2.7.5 - Bug 389815 - Enhancement Request - JSON specific multidimensional array support |
| package org.eclipse.persistence.oxm.record; |
| |
| import java.io.IOException; |
| import java.io.StringWriter; |
| import java.util.List; |
| |
| import javax.xml.namespace.QName; |
| |
| import org.eclipse.persistence.exceptions.XMLMarshalException; |
| import org.eclipse.persistence.internal.core.helper.CoreClassConstants; |
| import org.eclipse.persistence.internal.core.helper.CoreConversionManager; |
| import org.eclipse.persistence.internal.oxm.CharacterEscapeHandler; |
| import org.eclipse.persistence.internal.oxm.Constants; |
| import org.eclipse.persistence.internal.oxm.ConversionManager; |
| import org.eclipse.persistence.internal.oxm.NamespaceResolver; |
| import org.eclipse.persistence.internal.oxm.ObjectBuilder; |
| import org.eclipse.persistence.internal.oxm.Root; |
| import org.eclipse.persistence.internal.oxm.XMLBinaryDataHelper; |
| import org.eclipse.persistence.internal.oxm.XMLMarshaller; |
| import org.eclipse.persistence.internal.oxm.XPathFragment; |
| import org.eclipse.persistence.internal.oxm.mappings.Descriptor; |
| import org.eclipse.persistence.internal.oxm.record.ExtendedContentHandler; |
| import org.eclipse.persistence.internal.oxm.record.XMLFragmentReader; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Node; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.ext.LexicalHandler; |
| |
| public abstract class JsonRecord<T extends JsonRecord.Level> extends MarshalRecord<XMLMarshaller> { |
| |
| protected T position; |
| protected CharacterEscapeHandler characterEscapeHandler; |
| protected String attributePrefix; |
| protected boolean isRootArray; |
| protected static final String NULL = "null"; |
| protected boolean isLastEventStart; |
| |
| /** |
| * INTERNAL: |
| */ |
| @Override |
| public void setMarshaller(XMLMarshaller marshaller) { |
| super.setMarshaller(marshaller); |
| attributePrefix = marshaller.getAttributePrefix(); |
| if (marshaller.getValueWrapper() != null) { |
| textWrapperFragment = new XPathFragment(); |
| textWrapperFragment.setLocalName(marshaller.getValueWrapper()); |
| } |
| characterEscapeHandler = marshaller.getCharacterEscapeHandler(); |
| } |
| |
| @Override |
| public void forceValueWrapper() { |
| setComplex(position, true); |
| isLastEventStart = false; |
| } |
| |
| @Override |
| public void startDocument(String encoding, String version) { |
| if (isRootArray) { |
| if (position == null) { |
| startCollection(); |
| } |
| position.setEmptyCollection(false); |
| |
| position = createNewLevel(false, position, false); |
| |
| isLastEventStart = true; |
| } else { |
| startRootObject(); |
| } |
| } |
| |
| protected T createNewLevel(boolean collection, T parentLevel, boolean nestedArray) { |
| return (T) new Level(collection, position, nestedArray); |
| } |
| |
| protected void startRootObject() { |
| position = createNewLevel(false, null, false); |
| } |
| |
| |
| @Override |
| public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) { |
| super.openStartElement(xPathFragment, namespaceResolver); |
| String keyName1 = getKeyName(xPathFragment); |
| if (position != null && position.isCollection && xPathFragment.getXMLField() != null && xPathFragment.getXMLField().isNestedArray() |
| && this.marshaller.getJsonTypeConfiguration().isJsonDisableNestedArrayName()) { |
| position.addSkip(); |
| position.setKeyName(keyName1); |
| if (!position.isEmptyCollectionGenerated()) { |
| startEmptyCollection(); |
| position.setEmptyCollectionGenerated(true); |
| } |
| return; |
| } |
| if (position != null) { |
| T newLevel; |
| if (xPathFragment.getXMLField() != null && xPathFragment.getXMLField().isNestedArray() && this.marshaller.getJsonTypeConfiguration().isJsonDisableNestedArrayName()) { |
| newLevel = createNewLevel(false, position, true); |
| } else { |
| newLevel = createNewLevel(false, position, false); |
| } |
| |
| if (isLastEventStart) { |
| //this means 2 startevents in a row so the last this is a complex object |
| setComplex(position, true); |
| } |
| |
| String keyName = getKeyName(xPathFragment); |
| if (keyName != null && !keyName.equals(Constants.EMPTY_STRING)) { |
| if (position.isCollection && position.isEmptyCollection()) { |
| position.setKeyName(keyName); |
| startEmptyCollection(); |
| } else { |
| newLevel.setKeyName(keyName); |
| } |
| } |
| if (!(newLevel.isNestedArray() && newLevel.isComplex())) { |
| position = newLevel; |
| } |
| isLastEventStart = true; |
| } |
| } |
| |
| protected void startEmptyCollection() { |
| } |
| |
| /** |
| * Handle marshal of an empty collection. |
| * |
| * @param openGrouping if grouping elements should be marshalled for empty collections |
| */ |
| @Override |
| public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) { |
| |
| if (marshaller.isMarshalEmptyCollections()) { |
| super.emptyCollection(xPathFragment, namespaceResolver, true); |
| |
| if (null != xPathFragment) { |
| |
| if (xPathFragment.isSelfFragment() || xPathFragment.nameIsText()) { |
| String keyName = position.getKeyName(); |
| setComplex(position, false); |
| writeEmptyCollection((T) position.parentLevel, keyName); |
| } else { |
| if (isLastEventStart) { |
| setComplex(position, true); |
| } |
| String keyName = getKeyName(xPathFragment); |
| if (keyName != null) { |
| writeEmptyCollection(position, keyName); |
| } |
| } |
| isLastEventStart = false; |
| } |
| |
| return true; |
| } else { |
| return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping); |
| } |
| } |
| |
| protected abstract void writeEmptyCollection(T level, String keyName); |
| |
| @Override |
| public void endDocument() { |
| if (position != null) { |
| finishLevel(); |
| } |
| } |
| |
| protected void finishLevel() { |
| boolean notSkip = position.parentLevel == null || position.parentLevel.notSkip(); |
| if (notSkip) { |
| position = (T) position.parentLevel; |
| } |
| } |
| |
| @Override |
| public void startCollection() { |
| if (position == null) { |
| isRootArray = true; |
| position = createNewLevel(true, null, false); |
| startRootLevelCollection(); |
| } else { |
| if (isLastEventStart) { |
| setComplex(position, true); |
| } |
| position = createNewLevel(true, position, position.isNestedArray()); |
| } |
| isLastEventStart = false; |
| } |
| |
| protected void setComplex(T level, boolean complex) { |
| level.setComplex(complex); |
| } |
| |
| protected abstract void startRootLevelCollection(); |
| |
| protected String getKeyName(XPathFragment xPathFragment) { |
| String keyName = xPathFragment.getLocalName(); |
| |
| if (isNamespaceAware()) { |
| if (xPathFragment.getNamespaceURI() != null) { |
| String prefix = null; |
| if (getNamespaceResolver() != null) { |
| prefix = getNamespaceResolver().resolveNamespaceURI(xPathFragment.getNamespaceURI()); |
| } else if (namespaceResolver != null) { |
| prefix = namespaceResolver.resolveNamespaceURI(xPathFragment.getNamespaceURI()); |
| } |
| if (prefix != null && !prefix.equals(Constants.EMPTY_STRING)) { |
| keyName = prefix + getNamespaceSeparator() + keyName; |
| } |
| } |
| } |
| if (xPathFragment.isAttribute() && attributePrefix != null) { |
| keyName = attributePrefix + keyName; |
| } |
| |
| return keyName; |
| } |
| |
| @Override |
| public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, Object value, QName schemaType) { |
| if (xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI) { |
| return; |
| } |
| xPathFragment.setAttribute(true); |
| openStartElement(xPathFragment, namespaceResolver); |
| characters(schemaType, value, null, false, true); |
| endElement(xPathFragment, namespaceResolver); |
| } |
| |
| /** |
| * INTERNAL: |
| */ |
| @Override |
| public void marshalWithoutRootElement(ObjectBuilder treeObjectBuilder, Object object, Descriptor descriptor, Root root, boolean isXMLRoot) { |
| if (treeObjectBuilder != null) { |
| addXsiTypeAndClassIndicatorIfRequired(descriptor, null, descriptor.getDefaultRootElementField(), root, object, isXMLRoot, true); |
| treeObjectBuilder.marshalAttributes(this, object, session); |
| } |
| } |
| |
| /** |
| * INTERNAL: |
| * The character used to separate the prefix and uri portions when namespaces are present |
| * |
| * @since 2.4 |
| */ |
| @Override |
| public char getNamespaceSeparator() { |
| return marshaller.getNamespaceSeparator(); |
| } |
| |
| /** |
| * INTERNAL: |
| * The optional fragment used to wrap the text() mappings |
| * |
| * @since 2.4 |
| */ |
| @Override |
| public XPathFragment getTextWrapperFragment() { |
| return textWrapperFragment; |
| } |
| |
| @Override |
| public boolean isWrapperAsCollectionName() { |
| return marshaller.isWrapperAsCollectionName(); |
| } |
| |
| @Override |
| public void element(XPathFragment frag) { |
| isLastEventStart = false; |
| } |
| |
| |
| @Override |
| public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, String value) { |
| attribute(xPathFragment, namespaceResolver, value, null); |
| } |
| |
| @Override |
| public void attribute(String namespaceURI, String localName, String qName, String value) { |
| XPathFragment xPathFragment = new XPathFragment(); |
| xPathFragment.setNamespaceURI(namespaceURI); |
| xPathFragment.setAttribute(true); |
| xPathFragment.setLocalName(localName); |
| |
| openStartElement(xPathFragment, namespaceResolver); |
| characters(null, value, null, false, true); |
| |
| endElement(xPathFragment, namespaceResolver); |
| |
| } |
| |
| @Override |
| public void closeStartElement() { |
| } |
| |
| @Override |
| public void characters(String value) { |
| writeValue(value, null, false); |
| } |
| |
| @Override |
| public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA) { |
| characters(schemaType, value, mimeType, isCDATA, false); |
| } |
| |
| public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA, boolean isAttribute) { |
| if (mimeType != null) { |
| if (value instanceof List) { |
| value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesListForBinaryValues((List) value, marshaller, mimeType); |
| } else { |
| |
| value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(value, marshaller, mimeType).getData(); |
| } |
| } |
| if (schemaType != null && Constants.QNAME_QNAME.equals(schemaType)) { |
| String convertedValue = getStringForQName((QName) value); |
| writeValue(convertedValue, null, isAttribute); |
| } else if (value.getClass() == String.class) { |
| //if schemaType is set and it's a numeric or boolean type don't treat as a string |
| if (schemaType != null && isNumericOrBooleanType(schemaType)) { |
| ConversionManager conversionManager = getConversionManager(); |
| Class<?> theClass = conversionManager.javaType(schemaType); |
| Object convertedValue = conversionManager.convertObject(value, theClass, schemaType); |
| writeValue(convertedValue, schemaType, isAttribute); |
| } else if (isCDATA) { |
| cdata((String) value); |
| } else { |
| writeValue(value, null, isAttribute); |
| } |
| } else { |
| Class<?> theClass = ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).javaType(schemaType); |
| |
| if (schemaType == null || theClass == null) { |
| if (value.getClass() == CoreClassConstants.BOOLEAN || CoreClassConstants.NUMBER.isAssignableFrom(value.getClass())) { |
| writeValue(value, schemaType, isAttribute); |
| } else { |
| String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType)); |
| writeValue(convertedValue, schemaType, isAttribute); |
| } |
| } else if (schemaType != null && !isNumericOrBooleanType(schemaType)) { |
| //if schemaType exists and is not boolean or number do write quotes (convert to string) |
| String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType)); |
| writeValue(convertedValue, schemaType, isAttribute); |
| } else if (isCDATA) { |
| String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType)); |
| cdata(convertedValue); |
| } else { |
| writeValue(value, schemaType, isAttribute); |
| } |
| } |
| } |
| |
| |
| private boolean isNumericOrBooleanType(QName schemaType) { |
| if (schemaType == null) { |
| return false; |
| } else if (schemaType.equals(Constants.BOOLEAN_QNAME) |
| || schemaType.equals(Constants.INTEGER_QNAME) |
| || schemaType.equals(Constants.INT_QNAME) |
| || schemaType.equals(Constants.BYTE_QNAME) |
| || schemaType.equals(Constants.DECIMAL_QNAME) |
| || schemaType.equals(Constants.FLOAT_QNAME) |
| || schemaType.equals(Constants.DOUBLE_QNAME) |
| || schemaType.equals(Constants.SHORT_QNAME) |
| || schemaType.equals(Constants.LONG_QNAME) |
| || schemaType.equals(Constants.NEGATIVE_INTEGER_QNAME) |
| || schemaType.equals(Constants.NON_NEGATIVE_INTEGER_QNAME) |
| || schemaType.equals(Constants.NON_POSITIVE_INTEGER_QNAME) |
| || schemaType.equals(Constants.POSITIVE_INTEGER_QNAME) |
| || schemaType.equals(Constants.UNSIGNED_BYTE_QNAME) |
| || schemaType.equals(Constants.UNSIGNED_INT_QNAME) |
| || schemaType.equals(Constants.UNSIGNED_LONG_QNAME) |
| || schemaType.equals(Constants.UNSIGNED_SHORT_QNAME) |
| ) { |
| return true; |
| } |
| return false; |
| } |
| |
| public void writeValue(Object value, QName schemaType, boolean isAttribute) { |
| |
| if (characterEscapeHandler != null && value instanceof String) { |
| try { |
| StringWriter stringWriter = new StringWriter(); |
| characterEscapeHandler.escape(((String) value).toCharArray(), 0, ((String) value).length(), isAttribute, stringWriter); |
| value = stringWriter.toString(); |
| } catch (IOException e) { |
| throw XMLMarshalException.marshalException(e); |
| } |
| } |
| |
| boolean textWrapperOpened = false; |
| if (!isLastEventStart) { |
| openStartElement(textWrapperFragment, namespaceResolver); |
| textWrapperOpened = true; |
| } |
| |
| T currentLevel = position; |
| String keyName = position.getKeyName(); |
| if (!position.isComplex) { |
| currentLevel = (T) position.parentLevel; |
| } |
| addValue(currentLevel, keyName, value, schemaType); |
| isLastEventStart = false; |
| if (textWrapperOpened) { |
| endElement(textWrapperFragment, namespaceResolver); |
| } |
| } |
| |
| @Override |
| public void endElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) { |
| if (position != null) { |
| if (isLastEventStart) { |
| setComplex(position, true); |
| } |
| if (position.isComplex) { |
| finishLevel(); |
| } else { |
| position = (T) position.parentLevel; |
| } |
| isLastEventStart = false; |
| } |
| } |
| |
| private void addValue(T currentLevel, String keyName, Object value, QName schemaType) { |
| if (currentLevel.isCollection()) { |
| addValueToArray(currentLevel, value, schemaType); |
| currentLevel.setEmptyCollection(false); |
| } else { |
| addValueToObject(currentLevel, keyName, value, schemaType); |
| } |
| } |
| |
| protected abstract void addValueToObject(T currentLevel, String keyName, Object value, QName schemaType); |
| |
| protected abstract void addValueToArray(T currentLevel, Object value, QName schemaType); |
| |
| @Override |
| public void cdata(String value) { |
| characters(value); |
| } |
| |
| @Override |
| public void node(Node node, NamespaceResolver resolver, String uri, String name) { |
| |
| if (node.getNodeType() == Node.ATTRIBUTE_NODE) { |
| Attr attr = (Attr) node; |
| String resolverPfx = null; |
| if (getNamespaceResolver() != null) { |
| resolverPfx = this.getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI()); |
| } |
| // If the namespace resolver contains a prefix for the attribute's URI, |
| // use it instead of what is set on the attribute |
| if (resolverPfx != null) { |
| attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, resolverPfx + Constants.COLON + attr.getLocalName(), attr.getNodeValue()); |
| } else { |
| attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, attr.getName(), attr.getNodeValue()); |
| // May need to declare the URI locally |
| if (attr.getNamespaceURI() != null) { |
| attribute(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, Constants.EMPTY_STRING, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON + attr.getPrefix(), attr.getNamespaceURI()); |
| this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI()); |
| } |
| } |
| } else if (node.getNodeType() == Node.TEXT_NODE) { |
| writeValue(node.getNodeValue(), null, false); |
| } else { |
| try { |
| JsonRecordContentHandler wrcHandler = new JsonRecordContentHandler(); |
| |
| XMLFragmentReader xfragReader = new XMLFragmentReader(namespaceResolver); |
| xfragReader.setContentHandler(wrcHandler); |
| xfragReader.setProperty("http://xml.org/sax/properties/lexical-handler", wrcHandler); |
| xfragReader.parse(node, uri, name); |
| } catch (SAXException sex) { |
| throw XMLMarshalException.marshalException(sex); |
| } |
| } |
| |
| } |
| |
| @Override |
| protected String getStringForQName(QName qName) { |
| if (null == qName) { |
| return null; |
| } |
| CoreConversionManager xmlConversionManager = getSession().getDatasourcePlatform().getConversionManager(); |
| |
| return (String) xmlConversionManager.convertObject(qName, String.class); |
| } |
| |
| /** |
| * INTERNAL: |
| */ |
| @Override |
| public void namespaceDeclarations(NamespaceResolver namespaceResolver) { |
| } |
| |
| @Override |
| public void namespaceDeclaration(String prefix, String namespaceURI) { |
| } |
| |
| @Override |
| public void defaultNamespaceDeclaration(String defaultNamespace) { |
| } |
| |
| /** |
| * INTERNAL: |
| */ |
| @Override |
| public void nilComplex(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) { |
| XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver); |
| closeStartGroupingElements(groupingFragment); |
| openStartElement(xPathFragment, namespaceResolver); |
| characters(NULL); |
| endElement(xPathFragment, namespaceResolver); |
| } |
| |
| /** |
| * INTERNAL: |
| */ |
| @Override |
| public void nilSimple(NamespaceResolver namespaceResolver) { |
| XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver); |
| characters(NULL); |
| closeStartGroupingElements(groupingFragment); |
| } |
| |
| /** |
| * Used when an empty simple value should be written |
| * |
| * @since EclipseLink 2.4 |
| */ |
| @Override |
| public void emptySimple(NamespaceResolver namespaceResolver) { |
| nilSimple(namespaceResolver); |
| } |
| |
| @Override |
| public void emptyAttribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) { |
| XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver); |
| openStartElement(xPathFragment, namespaceResolver); |
| characters(NULL); |
| endElement(xPathFragment, namespaceResolver); |
| closeStartGroupingElements(groupingFragment); |
| } |
| |
| /** |
| * Used when an empty complex item should be written |
| * |
| * @since EclipseLink 2.4 |
| */ |
| @Override |
| public void emptyComplex(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) { |
| XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver); |
| closeStartGroupingElements(groupingFragment); |
| openStartElement(xPathFragment, namespaceResolver); |
| endElement(xPathFragment, namespaceResolver); |
| } |
| |
| |
| /** |
| * This class will typically be used in conjunction with an XMLFragmentReader. |
| * The XMLFragmentReader will walk a given XMLFragment node and report events |
| * to this class - the event's data is then written to the enclosing class' |
| * writer. |
| * |
| * @see org.eclipse.persistence.internal.oxm.record.XMLFragmentReader |
| */ |
| protected class JsonRecordContentHandler implements ExtendedContentHandler, LexicalHandler { |
| |
| JsonRecordContentHandler() { |
| } |
| |
| // --------------------- CONTENTHANDLER METHODS --------------------- // |
| @Override |
| public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException { |
| XPathFragment xPathFragment = new XPathFragment(localName); |
| xPathFragment.setNamespaceURI(namespaceURI); |
| openStartElement(xPathFragment, namespaceResolver); |
| handleAttributes(atts); |
| } |
| |
| @Override |
| public void endElement(String namespaceURI, String localName, String qName) throws SAXException { |
| XPathFragment xPathFragment = new XPathFragment(localName); |
| xPathFragment.setNamespaceURI(namespaceURI); |
| |
| JsonRecord.this.endElement(xPathFragment, namespaceResolver); |
| } |
| |
| @Override |
| public void startPrefixMapping(String prefix, String uri) throws SAXException { |
| } |
| |
| @Override |
| public void characters(char[] ch, int start, int length) throws SAXException { |
| String characters = new String(ch, start, length); |
| characters(characters); |
| } |
| |
| @Override |
| public void characters(CharSequence characters) throws SAXException { |
| JsonRecord.this.characters(characters.toString()); |
| } |
| |
| // --------------------- LEXICALHANDLER METHODS --------------------- // |
| @Override |
| public void comment(char[] ch, int start, int length) throws SAXException { |
| } |
| |
| @Override |
| public void startCDATA() throws SAXException { |
| } |
| |
| @Override |
| public void endCDATA() throws SAXException { |
| } |
| |
| // --------------------- CONVENIENCE METHODS --------------------- // |
| protected void handleAttributes(Attributes atts) { |
| for (int i = 0, attsLength = atts.getLength(); i < attsLength; i++) { |
| String qName = atts.getQName(i); |
| if ((qName != null && (qName.startsWith(javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON) || qName.equals(javax.xml.XMLConstants.XMLNS_ATTRIBUTE)))) { |
| continue; |
| } |
| attribute(atts.getURI(i), atts.getLocalName(i), qName, atts.getValue(i)); |
| } |
| } |
| |
| protected void writeComment(char[] chars, int start, int length) { |
| } |
| |
| protected void writeCharacters(char[] chars, int start, int length) { |
| try { |
| characters(chars, start, length); |
| } catch (SAXException e) { |
| throw XMLMarshalException.marshalException(e); |
| } |
| } |
| |
| // --------------- SATISFY CONTENTHANDLER INTERFACE --------------- // |
| @Override |
| public void endPrefixMapping(String prefix) throws SAXException { |
| } |
| |
| @Override |
| public void processingInstruction(String target, String data) throws SAXException { |
| } |
| |
| @Override |
| public void setDocumentLocator(Locator locator) { |
| } |
| |
| @Override |
| public void startDocument() throws SAXException { |
| } |
| |
| @Override |
| public void endDocument() throws SAXException { |
| } |
| |
| @Override |
| public void skippedEntity(String name) throws SAXException { |
| } |
| |
| @Override |
| public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException { |
| } |
| |
| // --------------- SATISFY LEXICALHANDLER INTERFACE --------------- // |
| @Override |
| public void startEntity(String name) throws SAXException { |
| } |
| |
| @Override |
| public void endEntity(String name) throws SAXException { |
| } |
| |
| @Override |
| public void startDTD(String name, String publicId, String systemId) throws SAXException { |
| } |
| |
| @Override |
| public void endDTD() throws SAXException { |
| } |
| |
| @Override |
| public void setNil(boolean isNil) { |
| } |
| |
| } |
| |
| |
| /** |
| * Instances of this class are used to maintain state about the current |
| * level of the JSON message being marshalled. |
| */ |
| protected static class Level { |
| |
| protected boolean isCollection; |
| protected boolean emptyCollection; |
| protected boolean emptyCollectionGenerated; |
| protected String keyName; |
| protected boolean isComplex; |
| protected boolean nestedArray; |
| protected Level parentLevel; |
| private int skipCount; |
| |
| public Level(boolean isCollection, Level parentLevel, boolean nestedArray) { |
| setCollection(isCollection); |
| emptyCollection = true; |
| this.parentLevel = parentLevel; |
| this.nestedArray = nestedArray; |
| this.skipCount = 0; |
| } |
| |
| protected void addSkip() { |
| skipCount++; |
| } |
| |
| protected boolean notSkip() { |
| if (skipCount > 0) { |
| skipCount--; |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| protected int getSkipCount() { |
| return skipCount; |
| } |
| |
| public boolean isCollection() { |
| return isCollection; |
| } |
| |
| public void setCollection(boolean isCollection) { |
| this.isCollection = isCollection; |
| } |
| |
| public String getKeyName() { |
| return keyName; |
| } |
| |
| public void setKeyName(String keyName) { |
| this.keyName = keyName; |
| } |
| |
| public boolean isEmptyCollection() { |
| return emptyCollection; |
| } |
| |
| public void setEmptyCollection(boolean emptyCollection) { |
| this.emptyCollection = emptyCollection; |
| } |
| |
| public boolean isEmptyCollectionGenerated() { |
| return emptyCollectionGenerated; |
| } |
| |
| public void setEmptyCollectionGenerated(boolean emptyCollectionGenerated) { |
| this.emptyCollectionGenerated = emptyCollectionGenerated; |
| } |
| |
| public boolean isComplex() { |
| return isComplex; |
| } |
| |
| public void setComplex(boolean isComplex) { |
| this.isComplex = isComplex; |
| } |
| |
| public boolean isNestedArray() { |
| return nestedArray; |
| } |
| |
| public void setNestedArray(boolean nestedArray) { |
| this.nestedArray = nestedArray; |
| } |
| |
| } |
| |
| } |
