Attachment #233675 for bug #411377

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 88-94 public class XMLCompositeCollectionMappingNodeValue extends XMLRelationshipMappi Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLCompositeCollectionMappingNodeValue.java (-1 / +2 lines)
88	} else {	88	} else {
89	return marshalRecord.emptyCollection(xPathFragment, namespaceResolver, xmlCompositeCollectionMapping.getWrapperNullPolicy() != null);	89	return marshalRecord.emptyCollection(xPathFragment, namespaceResolver, xmlCompositeCollectionMapping.getWrapperNullPolicy() != null);
90	}	90	}
91	marshalRecord.startCollection();	91
92		92
93	int size =marshalRecord.getCycleDetectionStack().size();	93	int size =marshalRecord.getCycleDetectionStack().size();
94	//when writing the collection need to see if any of the objects we are writing are in the parent collection inverse ref	94	//when writing the collection need to see if any of the objects we are writing are in the parent collection inverse ref
Lines 98-103 public class XMLCompositeCollectionMappingNodeValue extends XMLRelationshipMappi Link Here
98	return false;	98	return false;
99	}	99	}
100	}	100	}
		101	marshalRecord.startCollection();
101	iterator = cp.iteratorFor(collection);	102	iterator = cp.iteratorFor(collection);
102	while (cp.hasNext(iterator)) {	103	while (cp.hasNext(iterator)) {
103	Object objectValue = cp.next(iterator, session);	104	Object objectValue = cp.next(iterator, session);




/*******************************************************************************
 * Copyright (c) 2013 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 v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Denise Smith - 2.6 - initial implementation
 ******************************************************************************/
package org.eclipse.persistence.internal.oxm.record;

import javax.xml.transform.Result;

public abstract class ExtendedResult implements Result {

    private String systemId;

    public abstract org.eclipse.persistence.oxm.record.MarshalRecord createRecord();
    
    @Override
    public void setSystemId(String systemId) {
        this.systemId = systemId;        
    }

    @Override
    public String getSystemId() {
        return systemId;
    }
}





import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.oxm.CollectionGroupingElementNodeValue;
import org.eclipse.persistence.internal.oxm.ConversionManager;
import org.eclipse.persistence.internal.oxm.Constants;
import org.eclipse.persistence.internal.oxm.ContainerValue;
import org.eclipse.persistence.internal.oxm.MappingNodeValue;
import org.eclipse.persistence.internal.oxm.MediaType;
import org.eclipse.persistence.internal.oxm.NamespaceResolver;
import org.eclipse.persistence.internal.oxm.NodeValue;
import org.eclipse.persistence.internal.oxm.Root;
import org.eclipse.persistence.internal.oxm.Unmarshaller;
import org.eclipse.persistence.internal.oxm.XPathFragment;
import org.eclipse.persistence.internal.oxm.mappings.Field;
import org.eclipse.persistence.internal.oxm.record.AbstractUnmarshalRecord;
import org.eclipse.persistence.internal.oxm.record.SAXUnmarshallerHandler;
import org.eclipse.persistence.internal.oxm.record.UnmarshalRecord;
import org.eclipse.persistence.internal.oxm.XPathNode;
import org.eclipse.persistence.internal.oxm.record.XMLReaderAdapter;
import org.eclipse.persistence.internal.oxm.record.deferred.DeferredContentHandler;
import org.eclipse.persistence.oxm.mappings.nullpolicy.AbstractNullPolicy;
import org.eclipse.persistence.oxm.record.XMLRootRecord;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

public class JsonStructureReader extends JsonPReader {

    private static final String TRUE = "true";
    private static final String FALSE = "false";
    private String attributePrefix = null;
    private NamespaceResolver namespaces = null;
    private boolean includeRoot;
    private String textWrapper;
    private Class unmarshalClass;
    private boolean isInCollection;
    private JsonStructure jsonStructure;
    private JsonAttributes attributes = new JsonAttributes();


    public JsonStructureReader(Unmarshaller u) {
        this(u, null);        
    }
    
    public JsonStructureReader(Unmarshaller u, Class clazz) {
        super(u.getAttributePrefix(), u.getNamespaceResolver(), u.getNamespaceResolver() != null, u.isIncludeRoot(), u.getNamespaceSeparator(), u.getErrorHandler(), u.getValueWrapper(), clazz);
    }

    private JsonStructureReader(String attrPrefix, NamespaceResolver nr,boolean namespaceAware, boolean includeRoot,Character namespaceSeparator, ErrorHandler errorHandler, String textWrapper, Class unmarshalClass) {
        this.attributePrefix = attrPrefix;
        if (attributePrefix == Constants.EMPTY_STRING) {
            attributePrefix = null;
        }
        namespaces = nr;
        this.namespaceAware = namespaceAware;
        if (namespaceSeparator == null) {
            this.namespaceSeparator = Constants.DOT;
        } else {
            this.namespaceSeparator = namespaceSeparator;
        }
        this.includeRoot = includeRoot;
        this.setErrorHandler(errorHandler);
        this.textWrapper = textWrapper;
        this.unmarshalClass = unmarshalClass;
    }
    

    public void setJsonStructure(JsonStructure jsonStructure) {
        this.jsonStructure = jsonStructure;

        }
    }

    @Override
    public void parse(String systemId) {
        try {
            parse(new InputSource(systemId));
        } catch (IOException e) {
            throw XMLMarshalException.unmarshalException(e);
        } catch (SAXException e) {
            throw XMLMarshalException.unmarshalException(e);
        }
    }

    public void parseRoot(JsonValue jsonValue) throws SAXException {
        if (namespaces != null) {
            Map<String, String> namespacePairs = namespaces.getPrefixesToNamespaces();


    }

    public boolean isNullRepresentedByXsiNil(AbstractNullPolicy nullPolicy) {
        return true;
    }

    private void startCollection() {
        isInCollection = true;
    }

    private void endCollection() {
        isInCollection = false;
    }

    public boolean isInCollection() {
        return isInCollection;
    }

    private boolean isTextValue(String localName) {
        XPathNode currentNode = ((UnmarshalRecord) contentHandler).getXPathNode();
        if (currentNode == null) {
            return textWrapper != null && textWrapper.equals(localName);
        }

        return ((currentNode.getNonAttributeChildrenMap() == null || currentNode.getNonAttributeChildrenMap().size() == 0 || (currentNode.getNonAttributeChildrenMap().size() == 1 && currentNode.getTextNode() != null))&& textWrapper != null && textWrapper.equals(localName));
    }

    @Override
    public Object convertValueBasedOnSchemaType(Field xmlField, Object value, ConversionManager conversionManager, AbstractUnmarshalRecord record) {
        if (xmlField.getSchemaType() != null) {
            if (Constants.QNAME_QNAME.equals(xmlField.getSchemaType())) {
                String stringValue = (String) value;
                int indexOpen = stringValue.indexOf('{');
                int indexClose = stringValue.indexOf('}');
                String uri = null;
                String localName = null;
                if (indexOpen > -1 && indexClose > -1) {
                    uri = stringValue.substring(indexOpen + 1, indexClose);
                    localName = stringValue.substring(indexClose + 1);
                } else {
                    QName obj = (QName) xmlField.convertValueBasedOnSchemaType(stringValue, conversionManager, record);
                    localName = obj.getLocalPart();
                    uri = obj.getNamespaceURI();
                }
                if (uri != null) {
                    return new QName(uri, localName);
                } else {
                    return new QName(localName);
                }
            } else {
                Class fieldType = xmlField.getType();
                if (fieldType == null) {
                    fieldType = xmlField.getJavaClass(xmlField.getSchemaType());
                }
                return conversionManager.convertObject(value, fieldType, xmlField.getSchemaType());
            }
        }
        return value;
    }

    /**
     * INTERNAL: The MediaType associated with this reader
     * 
     * @return
     */
    @Override
    public MediaType getMediaType() {
        return Constants.APPLICATION_JSON;
    }

    private static class JsonAttributes extends IndexedAttributeList {

        private JsonValue value;




 ******************************************************************************/
package org.eclipse.persistence.oxm;

import java.util.Collection;
import java.util.Properties;

import javax.xml.transform.Result;

import org.eclipse.persistence.internal.oxm.TreeObjectBuilder;
import org.eclipse.persistence.internal.oxm.XMLObjectBuilder;
import org.eclipse.persistence.internal.oxm.XPathEngine;
import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.oxm.documentpreservation.DocumentPreservationPolicy;

            }
        }else{
            Class objectClass = object.getClass();
            if(result instanceof ExtendedResult){
                MarshalRecord writerRecord = ((ExtendedResult)result).createRecord();
                if(object instanceof Collection){
                    writerRecord.startCollection();
                    for(Object o : (Collection) object) {                        
                        marshal(o, writerRecord);
                    }
                    writerRecord.endCollection();
                    return;
                }else{
                    marshal(object, writerRecord);
                    return;
                }
            }
            if(session == null || xmlDescriptor == null){
                session = context.getSession(objectClass);
                xmlDescriptor = getDescriptor(objectClass, session);
            }
            
            
        }

        //if this is a simple xml root, the session and descriptor will be null




/*******************************************************************************
 * Copyright (c) 2013 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 v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Denise Smith - 2.6 - initial implementation
 ******************************************************************************/
package org.eclipse.persistence.oxm.json;

import javax.json.Json;
import javax.json.JsonArrayBuilder;
import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
import org.eclipse.persistence.oxm.record.JsonObjectBuilderWriterRecord;


public class JsonArrayBuilderResult extends ExtendedResult{

    private JsonArrayBuilder jsonArrayBuilder;
        
    public JsonArrayBuilderResult(){
        this.jsonArrayBuilder = Json.createArrayBuilder();
    }
    
    public JsonArrayBuilderResult(JsonArrayBuilder jsonArrayBuilder){
        this.jsonArrayBuilder = jsonArrayBuilder;
    }

    @Override
    public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
         return new JsonObjectBuilderWriterRecord(jsonArrayBuilder);
    }

    public JsonArrayBuilder getJsonArrayBuilder() {
        return jsonArrayBuilder;
    }

}




/*******************************************************************************
 * Copyright (c) 2013 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 v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Denise Smith - 2.6 - initial implementation
 ******************************************************************************/
package org.eclipse.persistence.oxm.json;

import javax.json.Json;
import javax.json.JsonObjectBuilder;
import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
import org.eclipse.persistence.oxm.record.JsonObjectBuilderWriterRecord;


public class JsonObjectBuilderResult extends ExtendedResult{

    private JsonObjectBuilder jsonObjectBuilder;
    
    public JsonObjectBuilderResult(){        
        this.jsonObjectBuilder = Json.createObjectBuilder();
    }
    
    public JsonObjectBuilderResult(JsonObjectBuilder jsonObjectBuilder){
        this.jsonObjectBuilder = jsonObjectBuilder;
    }

    @Override
    public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
         return new JsonObjectBuilderWriterRecord(jsonObjectBuilder);
    }

    public JsonObjectBuilder getJsonObjectBuilder() {
        return jsonObjectBuilder;
    }

}




import java.io.OutputStream;
import java.io.Writer;

import org.eclipse.persistence.exceptions.JAXBException;
import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.oxm.Constants;
import org.eclipse.persistence.internal.oxm.NamespaceResolver;

                }
            }
            if(xPathFragment.nameIsText()){
               if(position != null && position.isCollection() && position.isEmptyCollection()) {            	    
            	    if(!charactersAllowed){
              		     throw JAXBException.jsonValuePropertyRequired("[");   
              	    }
                    writer.write('[');
                    writer.write(' ');
                    position.setEmptyCollection(false);

Lines 247-256 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java (-4 / +7 lines)
247	}	247	}
248	}	248	}
249	if(xPathFragment.nameIsText()){	249	if(xPathFragment.nameIsText()){
250	if(position != null && position.isCollection() && position.isEmptyCollection()) {	250	if(position != null && position.isCollection() && position.isEmptyCollection()) {
251	if(!charactersAllowed){
252	throw JAXBException.jsonValuePropertyRequired("[");
253	}
254	writer.write('[');	251	writer.write('[');
255	position.setEmptyCollection(false);	252	position.setEmptyCollection(false);
256	position.setNeedToOpenComplex(false);	253	position.setNeedToOpenComplex(false);
Lines 377-382 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here
377	} else {	374	} else {
378	level.setCollection(true);	375	level.setCollection(true);
379	level.setEmptyCollection(true);	376	level.setEmptyCollection(true);
		377	charactersAllowed = false;
		378	isStartElementOpen = false;
380	}	379	}
381	}	380	}
382		381
Lines 421-426 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here
421	boolean textWrapperOpened = false;	420	boolean textWrapperOpened = false;
422	if(!charactersAllowed){	421	if(!charactersAllowed){
423	if(textWrapperFragment != null){	422	if(textWrapperFragment != null){
		423	if(!isStartElementOpen && level.isFirst()){
		424	level.needToOpenComplex = true;
		425	level.needToOpenComplex = true;
		426	}
424	openStartElement(textWrapperFragment, namespaceResolver);	427	openStartElement(textWrapperFragment, namespaceResolver);
425	textWrapperOpened = true;	428	textWrapperOpened = true;
426	}	429	}




package org.eclipse.persistence.oxm.record;

import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;

import javax.json.Json;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObjectBuilder;
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.XMLConversionManager;
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;


//TODO replace NULL string with addNUll
//TODO element method
public class JsonObjectBuilderWriterRecord extends MarshalRecord <XMLMarshaller> {

    private Level position;
    private JsonObjectBuilder rootJsonObjectBuilder;
    private JsonArrayBuilder rootJsonArrayBuilder;
    private CharacterEscapeHandler characterEscapeHandler;

    private String attributePrefix;
    private boolean isRootArray;
    private static final String NULL="null";
    private boolean isLastEventStart;
        
    public JsonObjectBuilderWriterRecord(){
        super();
        isLastEventStart = false;
    }
    
    public JsonObjectBuilderWriterRecord(JsonObjectBuilder jsonObjectBuilder){
        this();
        rootJsonObjectBuilder = jsonObjectBuilder;
    }
    
    public JsonObjectBuilderWriterRecord(JsonArrayBuilder jsonArrayBuilder){
        this();
        rootJsonArrayBuilder = jsonArrayBuilder;
    }
    
    /**
     * INTERNAL:
     */
    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 startDocument(String encoding, String version) {      
        if(isRootArray){
            position.setEmptyCollection(false);
            
            Level newLevel = new Level(false, position);
            position = newLevel;
            
            isLastEventStart = true;
        }else{
            Level rootLevel = new Level(false, null);
            position = rootLevel;
            if(rootJsonObjectBuilder == null){
                rootJsonObjectBuilder = Json.createObjectBuilder();
            }  
            
            rootLevel.setJsonObjectBuilder(rootJsonObjectBuilder);
        }
    }

    @Override
    public void endDocument() {
        if(position != null){
            if(position.parentLevel != null && position.parentLevel.isCollection){
                popAndSetInParentBuilder();
            }else{
                //this is the root level list case
                position = position.parentLevel;
            }            
        }
    }
    
    private void popAndSetInParentBuilder(){
        Level removedLevel = position;
        Level parentLevel = position.parentLevel;
        position = position.parentLevel;
        if(removedLevel.isCollection && removedLevel.isEmptyCollection() && removedLevel.keyName == null){
            return;
        }
      
        if(parentLevel != null){                  
            if(parentLevel.isCollection){
                if(removedLevel.isCollection){
                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonArrayBuilder());
                }else{                   
                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonObjectBuilder());
                }
            }else{
                if(removedLevel.isCollection){                    
                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonArrayBuilder());
                }else{
                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonObjectBuilder());
                }
            }
        }
        
    }    
    
    public void startCollection() {
        if(position == null){
             isRootArray = true;              
             Level rootLevel = new Level(true, null);
             if(rootJsonArrayBuilder == null){
                  rootJsonArrayBuilder = Json.createArrayBuilder();
             }
             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
             position = rootLevel;
        } else {            
            if(isLastEventStart){
                position.setComplex(true);           
            }            
            Level level = new Level(true, position);            
            position = level;
        }      
        isLastEventStart = false;
    }
    
    @Override
    public void endCollection() {
         popAndSetInParentBuilder();    
    }
    
    @Override    
    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
        super.openStartElement(xPathFragment, namespaceResolver);
        if(position != null){
            Level newLevel = new Level(false, position);            
            
            if(isLastEventStart){ 
                //this means 2 startevents in a row so the last this is a complex object
                position.setComplex(true);                                
            }
                      
            String keyName = getKeyName(xPathFragment);
           
            if(position.isCollection && position.isEmptyCollection() ){
                position.setKeyName(keyName);
            }else{
                newLevel.setKeyName(keyName);    
            }
            position = newLevel;   
            isLastEventStart = true;
        }
    }
    
    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;
    }

    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
     */
    public char getNamespaceSeparator(){        
        return marshaller.getNamespaceSeparator();
    }
    
    /**
     * INTERNAL:
     * The optional fragment used to wrap the text() mappings
     * @since 2.4
     */
    public XPathFragment getTextWrapperFragment() {
        return textWrapperFragment;
    }
    
    @Override
    public boolean isWrapperAsCollectionName() {
        return marshaller.isWrapperAsCollectionName();
    }
    
    @Override
    public void element(XPathFragment frag) {
        isLastEventStart = false;
    }
    
    /**
     * Handle marshal of an empty collection.  
     * @param xPathFragment
     * @param namespaceResolver
     * @param openGrouping if grouping elements should be marshalled for empty collections
     * @return
     */    
    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();
                     position.setComplex(false);
                     position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());                     
                 }else{ 
                     if(isLastEventStart){
                         position.setComplex(true);                  
                     }                 
                     String keyName =  getKeyName(xPathFragment);
                     if(keyName != null){
                        position.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
                     }
                 }
                 isLastEventStart = false;   
             }
                  
             return true;
         }else{
             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
         }
    }

    @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 endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
        if(position != null){
            if(isLastEventStart){
                position.setComplex(true);
            }
            if(position.isComplex){
                popAndSetInParentBuilder();
            }else{
                position = position.parentLevel;
            }            
            isLastEventStart = false;          
        }
    }

    @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)){
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);
                Object convertedValue = ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, theClass, schemaType);
                writeValue(convertedValue, schemaType, isAttribute);
            }else if(isCDATA){
                cdata((String)value);
            }else{
                writeValue((String)value, null, isAttribute);                
            }
       }else{
           Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(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;
        }
      
        Level currentLevel = position;
        String keyName = position.getKeyName();
        if(!position.isComplex){           
            currentLevel = position.parentLevel;
            currentLevel.setComplex(true);          
        }
        if(currentLevel.isCollection()){
            currentLevel.setEmptyCollection(false);
            addValueToArrayBuilder(currentLevel.getJsonArrayBuilder(), value, schemaType);            
        } else {
            JsonObjectBuilder builder = currentLevel.getJsonObjectBuilder();                   
            addValueToObjectBuilder(builder, keyName, value, schemaType);          
        }
        isLastEventStart = false;
        if(textWrapperOpened){    
             endElement(textWrapperFragment, namespaceResolver);
        }    
    }
    
    private void addValueToObjectBuilder(JsonObjectBuilder jsonObjectBuilder, String keyName, Object value, QName schemaType){
        if(value == NULL){
            jsonObjectBuilder.addNull(keyName);
        }else if(value instanceof Integer){
            jsonObjectBuilder.add(keyName, (Integer)value);  
        }else if(value instanceof BigDecimal){
            jsonObjectBuilder.add(keyName, (BigDecimal)value);   
        }else if(value instanceof BigInteger){
            jsonObjectBuilder.add(keyName, (BigInteger)value);               
        }else if(value instanceof Boolean){
            jsonObjectBuilder.add(keyName, (Boolean)value);
        }else if(value instanceof Character){
            jsonObjectBuilder.add(keyName, (Character)value);  
        }else if(value instanceof Double){
            jsonObjectBuilder.add(keyName, (Double)value);
        }else if(value instanceof Float){
            jsonObjectBuilder.add(keyName, (Float)value);
        }else if(value instanceof Long){
            jsonObjectBuilder.add(keyName, (Long)value);
        }else if(value instanceof String){
            jsonObjectBuilder.add(keyName, (String)value);                
        }else{
            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                //if it's still a number and falls through the cracks we dont want "" around the value
                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
                    jsonObjectBuilder.add(keyName, (BigDecimal)convertedNumberValue);
            }else{
                jsonObjectBuilder.add(keyName, convertedValue);
            }
                
        }
    }
    
    private void addValueToArrayBuilder(JsonArrayBuilder jsonArrayBuilder, Object value, QName schemaType){
        if(value == NULL){
            jsonArrayBuilder.addNull();
        }else if(value instanceof Integer){
            jsonArrayBuilder.add((Integer)value);  
        }else if(value instanceof BigDecimal){
            jsonArrayBuilder.add((BigDecimal)value);   
        }else if(value instanceof BigInteger){
            jsonArrayBuilder.add((BigInteger)value);               
        }else if(value instanceof Boolean){                
            jsonArrayBuilder.add((Boolean)value);
        }else if(value instanceof Character){
            jsonArrayBuilder.add((Character)value);  
        }else if(value instanceof Double){
            jsonArrayBuilder.add((Double)value);
        }else if(value instanceof Float){
            jsonArrayBuilder.add((Float)value);
        }else if(value instanceof Long){
            jsonArrayBuilder.add((Long)value);
        }else if(value instanceof String){
            jsonArrayBuilder.add((String)value);
        }else{
            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                //if it's still a number and falls through the cracks we dont want "" around the value
                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
                    jsonArrayBuilder.add((BigDecimal)convertedNumberValue);
            }else{
                jsonArrayBuilder.add(convertedValue);
            }
        }
    }
    
    @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());
            }
            String namespaceURI = 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 {
                JsonObjectBuilderRecordContentHandler wrcHandler = new JsonObjectBuilderRecordContentHandler();
                
                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);
            }
        }
        
    }        
    
    protected String getStringForQName(QName qName){
        if(null == qName) {
            return null;
        }
        CoreConversionManager xmlConversionManager = getSession().getDatasourcePlatform().getConversionManager();

        return (String) xmlConversionManager.convertObject(qName, String.class);       
    }

    /**
     * INTERNAL:
     */
     public void namespaceDeclarations(NamespaceResolver namespaceResolver) {
     }

     public void namespaceDeclaration(String prefix, String namespaceURI){
     }
     
     public void defaultNamespaceDeclaration(String defaultNamespace){
     }
     
    /**
     * INTERNAL:
     */
     public void nilComplex(XPathFragment xPathFragment, NamespaceResolver namespaceResolver){
         XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver);
         closeStartGroupingElements(groupingFragment);
         openStartElement(xPathFragment, namespaceResolver);
         characters(NULL);
         endElement(xPathFragment, namespaceResolver);
     }

    /**
     * INTERNAL:
     */
     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
      */
     public void emptySimple(NamespaceResolver namespaceResolver){
         nilSimple(namespaceResolver);
     }
     
     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
      */
     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 JsonObjectBuilderRecordContentHandler implements ExtendedContentHandler, LexicalHandler {

         JsonObjectBuilderRecordContentHandler() {
         }

         // --------------------- CONTENTHANDLER METHODS --------------------- //
         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);
         }

         public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
             XPathFragment xPathFragment = new XPathFragment(localName);
             xPathFragment.setNamespaceURI(namespaceURI);
             
             JsonObjectBuilderWriterRecord.this.endElement(xPathFragment, namespaceResolver);        
         }

         public void startPrefixMapping(String prefix, String uri) throws SAXException {
         }

         public void characters(char[] ch, int start, int length) throws SAXException {
             String characters = new String (ch, start, length);
             characters(characters);
         }

         public void characters(CharSequence characters) throws SAXException {           
             JsonObjectBuilderWriterRecord.this.characters(characters.toString());      
         }

         // --------------------- LEXICALHANDLER METHODS --------------------- //
         public void comment(char[] ch, int start, int length) throws SAXException {
         }

         public void startCDATA() throws SAXException {
         }

         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 --------------- //
         public void endPrefixMapping(String prefix) throws SAXException {}
         public void processingInstruction(String target, String data) throws SAXException {}
         public void setDocumentLocator(Locator locator) {}
         public void startDocument() throws SAXException {}
         public void endDocument() throws SAXException {}
         public void skippedEntity(String name) throws SAXException {}
         public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {}

         // --------------- SATISFY LEXICALHANDLER INTERFACE --------------- //
         public void startEntity(String name) throws SAXException {}
         public void endEntity(String name) throws SAXException {}
         public void startDTD(String name, String publicId, String systemId) throws SAXException {}
         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 {
        
        private boolean isCollection;
        private boolean emptyCollection;
        private String keyName;        
        private JsonObjectBuilder jsonObjectBuilder;
        private JsonArrayBuilder jsonArrayBuilder;
        private boolean isComplex;
        private Level parentLevel;
        
        public Level(boolean isCollection, Level parentLevel) {
            setCollection(isCollection);
            emptyCollection = true;
            this.parentLevel = parentLevel;
        }

        public boolean isCollection() {
            return isCollection;
        }

        public void setCollection(boolean isCollection) {
            this.isCollection = isCollection;
            if(isCollection && jsonArrayBuilder == null){
                jsonArrayBuilder = Json.createArrayBuilder();
            }
        }

        public String getKeyName() {
            return keyName;
        }

        public void setKeyName(String keyName) {
            this.keyName = keyName;
        }

        public JsonObjectBuilder getJsonObjectBuilder() {
            return jsonObjectBuilder;
        }

        public void setJsonObjectBuilder(JsonObjectBuilder jsonObjectBuilder) {
            this.jsonObjectBuilder = jsonObjectBuilder;
        }

        public JsonArrayBuilder getJsonArrayBuilder() {
            return jsonArrayBuilder;
        }

        public void setJsonArrayBuilder(JsonArrayBuilder jsonArrayBuilder) {
            this.jsonArrayBuilder = jsonArrayBuilder;
        }

        public boolean isEmptyCollection() {
            return emptyCollection;
        }

        public void setEmptyCollection(boolean emptyCollection) {
            this.emptyCollection = emptyCollection;
        }
        public boolean isComplex() {
            return isComplex;
        }

        public void setComplex(boolean isComplex) {
            this.isComplex = isComplex;
            if(isComplex && jsonObjectBuilder == null){
                jsonObjectBuilder = Json.createObjectBuilder();
            }
        }        
    }

}

Lines 1-7 Link Here

(-)a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/employee.json (-2 / +4 lines)
1	{"employee":{	1	{"employee":{
2	"things":{	2	"things":{
3	"junk":{	3	"junk":{
4	"stuff":"Some Stuff"	4	"stuff":{
		5	"value":["Some Stuff"]
		6	}
5	}	7	}
6	}	8	}
7	}}	9	}}

Lines 1-7 Link Here

(-)a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/write-only-employee.json (-1 / +3 lines)
1	{"employee":{	1	{"employee":{
2	"things":{	2	"things":{
3	"write-only":{	3	"write-only":{
4	"stuff":"Some Stuff"	4	"stuff":{
		5	"value":["Some Stuff"]
		6	}
5	}	7	}
6	}	8	}
7	}}	9	}}

Lines 1-6 Link Here

(-)a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/xmlidrefcontainment.json (-1 / +1 lines)
1	{"customer-data":{	1	{"customer-data":{
2	"customer":{	2	"customer":{
3	"customerID":"Alice",	3	"@customerID":"Alice",
4	"name":"Alice Jane",	4	"name":"Alice Jane",
5	"customerID":"Alice"	5	"customerID":"Alice"
6	},	6	},

Lines 23-30 import java.util.ArrayList; Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java (-1 / +27 lines)
23	import java.util.List;	23	import java.util.List;
24		24
25	import javax.json.Json;	25	import javax.json.Json;
		26	import javax.json.JsonObject;
		27	import javax.json.JsonObjectBuilder;
26	import javax.json.JsonReader;	28	import javax.json.JsonReader;
27	import javax.json.JsonStructure;	29	import javax.json.JsonStructure;
		30	import javax.json.JsonWriter;
		31	import javax.json.stream.JsonParser;
28	import javax.xml.bind.JAXBElement;	32	import javax.xml.bind.JAXBElement;
29	import javax.xml.bind.Marshaller;	33	import javax.xml.bind.Marshaller;
30	import javax.xml.bind.Unmarshaller;	34	import javax.xml.bind.Unmarshaller;
Lines 37-42 import org.eclipse.persistence.jaxb.JAXBContext; Link Here
37	import org.eclipse.persistence.jaxb.MarshallerProperties;	41	import org.eclipse.persistence.jaxb.MarshallerProperties;
38	import org.eclipse.persistence.jaxb.UnmarshallerProperties;	42	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
39	import org.eclipse.persistence.oxm.MediaType;	43	import org.eclipse.persistence.oxm.MediaType;
		44	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
40	import org.eclipse.persistence.oxm.json.JsonStructureSource;	45	import org.eclipse.persistence.oxm.json.JsonStructureSource;
41	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;	46	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
42	import org.xml.sax.InputSource;	47	import org.xml.sax.InputSource;
Lines 235-241 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
235	jsonToObjectTest(testObject);	240	jsonToObjectTest(testObject);
236	}	241	}
237	}	242	}
238		243
239	public void testJSONUnmarshalFromURL() throws Exception {	244	public void testJSONUnmarshalFromURL() throws Exception {
240	if(isUnmarshalTest()){	245	if(isUnmarshalTest()){
241	getJSONUnmarshaller().setProperty(UnmarshallerProperties.MEDIA_TYPE, getJSONUnmarshalMediaType());	246	getJSONUnmarshaller().setProperty(UnmarshallerProperties.MEDIA_TYPE, getJSONUnmarshalMediaType());
Lines 309-314 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
309	log(sw.toString());	314	log(sw.toString());
310	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());	315	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
311	}	316	}
		317	public void testJSONMarshalToBuilderResult() throws Exception{
		318	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
		319
		320	JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
		321	JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
		322	try{
		323	getJSONMarshaller().marshal(getWriteControlObject(), result);
		324	} catch(Exception e) {
		325	assertMarshalException(e);
		326	return;
		327	}
		328	JsonObject jsonObject = jsonObjectBuilder.build();
		329
		330	StringWriter sw = new StringWriter();
		331	JsonWriter writer= Json.createWriter(sw);
		332	writer.writeObject(jsonObject);
		333	writer.close();
		334
		335	log(sw.toString());
		336	compareStringToControlFile("testJSONMarshalToStringWriter", sw.toString());
		337	}
312		338
313	protected void compareStringToControlFile(String test, String testString) {	339	protected void compareStringToControlFile(String test, String testString) {
314	compareStringToControlFile(test, testString, getWriteControlJSON());	340	compareStringToControlFile(test, testString, getWriteControlJSON());

Lines 14-19 package org.eclipse.persistence.testing.jaxb.javadoc.xmlidref; Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/XmlIdRefContainmentTest.java (+3 lines)
14		14
15	//Example 2	15	//Example 2
16		16
		17	import org.eclipse.persistence.jaxb.MarshallerProperties;
17	import org.eclipse.persistence.testing.jaxb.JAXBWithJSONTestCases;	18	import org.eclipse.persistence.testing.jaxb.JAXBWithJSONTestCases;
18		19
19	public class XmlIdRefContainmentTest extends JAXBWithJSONTestCases{	20	public class XmlIdRefContainmentTest extends JAXBWithJSONTestCases{
Lines 31-36 public class XmlIdRefContainmentTest extends JAXBWithJSONTestCases{ Link Here
31	classes[2] = Shipping.class;	32	classes[2] = Shipping.class;
32	classes[3] = CustomerData.class;	33	classes[3] = CustomerData.class;
33	setClasses(classes);	34	setClasses(classes);
		35	jaxbMarshaller.setProperty(MarshallerProperties.JSON_ATTRIBUTE_PREFIX, "@");
		36	jaxbUnmarshaller.setProperty(MarshallerProperties.JSON_ATTRIBUTE_PREFIX, "@");
34	}	37	}
35		38
36	protected Object getControlObject() {	39	protected Object getControlObject() {

Lines 20-29 import java.net.URL; Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONMarshalUnmarshalTestCases.java (+21 lines)
20	import java.util.ArrayList;	20	import java.util.ArrayList;
21	import java.util.List;	21	import java.util.List;
22		22
		23	import javax.json.Json;
		24	import javax.json.JsonReader;
		25	import javax.json.JsonStructure;
23	import javax.xml.bind.JAXBElement;	26	import javax.xml.bind.JAXBElement;
24	import javax.xml.transform.stream.StreamSource;	27	import javax.xml.transform.stream.StreamSource;
25		28
26	import org.eclipse.persistence.jaxb.JAXBContext;	29	import org.eclipse.persistence.jaxb.JAXBContext;
		30	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
		31	import org.eclipse.persistence.oxm.json.JsonStructureSource;
27	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;	32	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
28	import org.xml.sax.InputSource;	33	import org.xml.sax.InputSource;
29		34
Lines 53-58 public abstract class JSONMarshalUnmarshalTestCases extends JSONTestCases{ Link Here
53	inputStream.close();	58	inputStream.close();
54	jsonToObjectTest(testObject);	59	jsonToObjectTest(testObject);
55	}	60	}
		61
		62	public void testJSONUnmarshalFromJsonStructureSource() throws Exception {
		63
		64	InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);
		65	JsonReader reader = Json.createReader(inputStream);
		66	JsonStructure jsonStructure = reader.read();
		67	JsonStructureSource source = new JsonStructureSource(jsonStructure);
		68
		69	Object testObject = null;
		70	if(getUnmarshalClass() != null){
		71	testObject = jsonUnmarshaller.unmarshal(source, getUnmarshalClass());
		72	}else{
		73	testObject = jsonUnmarshaller.unmarshal(source);
		74	}
		75	jsonToObjectTest(testObject);
		76	}
56		77
57	public void testJSONUnmarshalFromInputSource() throws Exception {	78	public void testJSONUnmarshalFromInputSource() throws Exception {
58	InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);	79	InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);

Lines 13-23 Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java (+53 lines)
13	package org.eclipse.persistence.testing.jaxb.json;	13	package org.eclipse.persistence.testing.jaxb.json;
14		14
15	import java.io.ByteArrayOutputStream;	15	import java.io.ByteArrayOutputStream;
		16	import java.io.OutputStream;
		17	import java.io.OutputStreamWriter;
16	import java.io.StringWriter;	18	import java.io.StringWriter;
		19	import java.nio.charset.Charset;
17	import java.util.Collection;	20	import java.util.Collection;
18	import java.util.Iterator;	21	import java.util.Iterator;
19	import java.util.Map;	22	import java.util.Map;
20		23
		24	import javax.json.Json;
		25	import javax.json.JsonArray;
		26	import javax.json.JsonArrayBuilder;
		27	import javax.json.JsonObject;
		28	import javax.json.JsonObjectBuilder;
		29	import javax.json.JsonWriter;
		30	import javax.json.JsonWriterFactory;
21	import javax.xml.bind.JAXBContext;	31	import javax.xml.bind.JAXBContext;
22	import javax.xml.bind.JAXBElement;	32	import javax.xml.bind.JAXBElement;
23	import javax.xml.bind.Marshaller;	33	import javax.xml.bind.Marshaller;
Lines 27-32 import org.eclipse.persistence.jaxb.JAXBContextFactory; Link Here
27	import org.eclipse.persistence.jaxb.MarshallerProperties;	37	import org.eclipse.persistence.jaxb.MarshallerProperties;
28	import org.eclipse.persistence.jaxb.UnmarshallerProperties;	38	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
29	import org.eclipse.persistence.oxm.XMLContext;	39	import org.eclipse.persistence.oxm.XMLContext;
		40	import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;
		41	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
30	import org.eclipse.persistence.testing.oxm.OXTestCase;	42	import org.eclipse.persistence.testing.oxm.OXTestCase;
31		43
32	public abstract class JSONTestCases extends OXTestCase{	44	public abstract class JSONTestCases extends OXTestCase{
Lines 172-178 public abstract class JSONTestCases extends OXTestCase{ Link Here
172	compareStringToControlFile("testJSONMarshalToOutputStream", new String(os.toByteArray()));	184	compareStringToControlFile("testJSONMarshalToOutputStream", new String(os.toByteArray()));
173	os.close();	185	os.close();
174	}	186	}
		187
		188	public void testJSONMarshalToBuilderResult() throws Exception{
		189	Object writeControlObject = getWriteControlObject();
		190	if(writeControlObject instanceof Collection \|\| writeControlObject.getClass().isArray()){
		191	marshalToArrayBuilderResult();
		192	}else{
		193	marshalToObjectBuilderResult();
		194	}
		195	}
		196
		197	public void marshalToObjectBuilderResult() throws Exception{
		198
		199	JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
		200	JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
		201	jsonMarshaller.marshal(getWriteControlObject(), result);
175		202
		203	JsonObject jsonObject = jsonObjectBuilder.build();
		204	StringWriter sw = new StringWriter();
		205
		206	JsonWriter writer= Json.createWriter(sw);
		207	writer.writeObject(jsonObject);
		208	writer.close();
		209	log(sw.toString());
		210	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());
		211	}
		212
		213	public void marshalToArrayBuilderResult() throws Exception{
		214
		215	JsonArrayBuilder jsonArrayBuilder = Json.createArrayBuilder();
		216	JsonArrayBuilderResult result = new JsonArrayBuilderResult(jsonArrayBuilder);
		217	jsonMarshaller.marshal(getWriteControlObject(), result);
		218
		219	JsonArray jsonArray = jsonArrayBuilder.build();
		220	StringWriter sw = new StringWriter();
		221	JsonWriter writer= Json.createWriter(sw);
		222	writer.writeArray(jsonArray);
		223	writer.close();
		224
		225	log(sw.toString());
		226	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());
		227	}
		228
176	public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{	229	public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
177	jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);	230	jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
178	ByteArrayOutputStream os = new ByteArrayOutputStream();	231	ByteArrayOutputStream os = new ByteArrayOutputStream();




		return holder;
	}

	protected void compareStrings(String test, String testString, String expectedString, boolean removeWhitespace) {
        log(test);
        log("Expected (With All Whitespace Removed):");
        if(removeWhitespace){
           expectedString = expectedString.replaceAll("[ \b\t\n\r ]", "");
        }
        log(expectedString);
           
        log("\nActual (With All Whitespace Removed):");
        if(removeWhitespace){
            testString = testString.replaceAll("[ \b\t\n\r]", "");
        }       
        log(testString);
        assertEquals(expectedString.toLowerCase(), testString.toLowerCase());
    }
	
}

Lines 12-21 Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java (+29 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.testing.jaxb.json.characters;	13	package org.eclipse.persistence.testing.jaxb.json.characters;
14		14
		15	import java.io.ByteArrayOutputStream;
		16	import java.io.OutputStreamWriter;
		17	import java.nio.charset.Charset;
15	import java.util.Map;	18	import java.util.Map;
16		19
		20	import javax.json.Json;
		21	import javax.json.JsonObject;
		22	import javax.json.JsonObjectBuilder;
		23	import javax.json.JsonWriter;
17	import javax.xml.bind.Marshaller;	24	import javax.xml.bind.Marshaller;
18		25
		26	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
19	import org.eclipse.persistence.testing.jaxb.json.JSONMarshalUnmarshalTestCases;	27	import org.eclipse.persistence.testing.jaxb.json.JSONMarshalUnmarshalTestCases;
20		28
21	public class UsAsciiTestCases extends JSONMarshalUnmarshalTestCases {	29	public class UsAsciiTestCases extends JSONMarshalUnmarshalTestCases {
Lines 43-47 public class UsAsciiTestCases extends JSONMarshalUnmarshalTestCases { Link Here
43	control.characters.add('b');	51	control.characters.add('b');
44	return control;	52	return control;
45	}	53	}
		54
		55	public void marshalToObjectBuilderResult() throws Exception{
		56
		57	JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
		58	JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
		59	jsonMarshaller.marshal(getWriteControlObject(), result);
		60
		61	JsonObject jsonObject = jsonObjectBuilder.build();
		62	ByteArrayOutputStream out = new ByteArrayOutputStream();
		63	Charset charset = Charset.forName("US-ASCII");
		64
		65	JsonWriter writer = Json.createWriterFactory(null).createWriter(out, charset);
		66
		67	writer.writeObject(jsonObject);
		68	writer.close();
		69
		70	String s = out.toString();
		71
		72	log(s);
		73	compareStringToControlFile("testJSONMarshalToBuilderResult", s);
		74	}
46		75
47	}	76	}

Lines 45-48 public class JAXBElementJSONPaddingTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java (+4 lines)
45	public boolean isUnmarshalTest (){	45	public boolean isUnmarshalTest (){
46	return false;	46	return false;
47	}	47	}
		48
		49	public void testJSONMarshalToBuilderResult() throws Exception{
		50	}
		51
48	}	52	}

Lines 57-60 public class JAXBElementListJSONPaddingTestCases extends JSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java (+3 lines)
57	public boolean isUnmarshalTest (){	57	public boolean isUnmarshalTest (){
58	return false;	58	return false;
59	}	59	}
		60
		61	public void testJSONMarshalToBuilderResult() throws Exception{
		62	}
60	}	63	}

Lines 42-45 public class JSONWithNullNameTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java (+4 lines)
42	public boolean isUnmarshalTest (){	42	public boolean isUnmarshalTest (){
43	return false;	43	return false;
44	}	44	}
		45
		46	public void testJSONMarshalToBuilderResult() throws Exception{
		47	}
		48
45	}	49	}

Lines 46-51 public class JSONWithNullObjectTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullObjectTestCases.java (+3 lines)
46	return false;	46	return false;
47	}	47	}
48		48
		49	public void testJSONMarshalToBuilderResult() throws Exception{
		50	}
		51
49	@Override	52	@Override
50	public void assertMarshalException(Exception exception) throws Exception {	53	public void assertMarshalException(Exception exception) throws Exception {
51	Exception nestedException = (Exception) exception.getCause();	54	Exception nestedException = (Exception) exception.getCause();

Lines 55-60 public class JSONWithPaddingSimpleListTestCases extends JSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java (+3 lines)
55	return false;	55	return false;
56	}	56	}
57		57
		58	public void testJSONMarshalToBuilderResult() throws Exception{
		59	}
		60
58	// public boolean shouldRemoveWhitespaceFromControlDocJSON(){	61	// public boolean shouldRemoveWhitespaceFromControlDocJSON(){
59	// return false;	62	// return false;
60	//}	63	//}

Lines 48-51 public class JSONWithPaddingSimpleTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java (+4 lines)
48	public boolean isUnmarshalTest (){	48	public boolean isUnmarshalTest (){
49	return false;	49	return false;
50	}	50	}
		51
		52	public void testJSONMarshalToBuilderResult() throws Exception{
		53	}
		54
51	}	55	}

Lines 42-45 public class JSONWithUnsetNameTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java (+4 lines)
42	public boolean isUnmarshalTest (){	42	public boolean isUnmarshalTest (){
43	return false;	43	return false;
44	}	44	}
		45
		46	public void testJSONMarshalToBuilderResult() throws Exception{
		47	}
		48
45	}	49	}




		fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToBuilderResult() throws Exception{
        try{
            super.testJSONMarshalToBuilderResult();
        }catch(JAXBException e){
            if(verifyException(e)){
                return;
            }
        }
        fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToStringWriter_FORMATTED() throws Exception{
    	try{
     		super.testJSONMarshalToStringWriter_FORMATTED();

Return to bug 411377

Lines 40-45 import org.eclipse.persistence.internal.core.sessions.CoreAbstractSession; Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java (-1 / +4 lines)
40	import org.eclipse.persistence.internal.oxm.mappings.Descriptor;	40	import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
41	import org.eclipse.persistence.internal.oxm.mappings.Field;	41	import org.eclipse.persistence.internal.oxm.mappings.Field;
42	import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;	42	import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;
		43	import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
43	import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;	44	import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;
44	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;	45	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
45	import org.eclipse.persistence.oxm.JSONWithPadding;	46	import org.eclipse.persistence.oxm.JSONWithPadding;
Lines 1004-1010 public abstract class XMLMarshaller< Link Here
1004	} else if (result instanceof SAXResult) {	1005	} else if (result instanceof SAXResult) {
1005	SAXResult saxResult = (SAXResult) result;	1006	SAXResult saxResult = (SAXResult) result;
1006	marshal(object, saxResult.getHandler());	1007	marshal(object, saxResult.getHandler());
1007	} else {	1008	} else if (result instanceof ExtendedResult){
		1009	marshal(object, ((ExtendedResult)result).createRecord(), session, xmlDescriptor, isXMLRoot);
		1010	}else {
1008	if (result.getClass().equals(staxResultClass)) {	1011	if (result.getClass().equals(staxResultClass)) {
1009	try {	1012	try {
1010	Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);	1013	Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);

Added Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java (+32 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
5	* which accompanies this distribution.
6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
7	* and the Eclipse Distribution License is available at
8	* http://www.eclipse.org/org/documents/edl-v10.php.
9	*
10	* Contributors:
11	* Denise Smith - 2.6 - initial implementation
12	******************************************************************************/
13	package org.eclipse.persistence.internal.oxm.record;
14
15	import javax.xml.transform.Result;
16
17	public abstract class ExtendedResult implements Result {
18
19	private String systemId;
20
21	public abstract org.eclipse.persistence.oxm.record.MarshalRecord createRecord();
22
23	@Override
24	public void setSystemId(String systemId) {
25	this.systemId = systemId;
26	}
27
28	@Override
29	public String getSystemId() {
30	return systemId;
31	}
32	}

Lines 40-109 import javax.xml.namespace.QName; Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/json/JsonStructureReader.java (-116 / +2 lines)
40		40
41	import org.eclipse.persistence.exceptions.XMLMarshalException;	41	import org.eclipse.persistence.exceptions.XMLMarshalException;
42	import org.eclipse.persistence.internal.oxm.CollectionGroupingElementNodeValue;	42	import org.eclipse.persistence.internal.oxm.CollectionGroupingElementNodeValue;
43	import org.eclipse.persistence.internal.oxm.ConversionManager;
44	import org.eclipse.persistence.internal.oxm.Constants;	43	import org.eclipse.persistence.internal.oxm.Constants;
45	import org.eclipse.persistence.internal.oxm.ContainerValue;	44	import org.eclipse.persistence.internal.oxm.ContainerValue;
46	import org.eclipse.persistence.internal.oxm.MappingNodeValue;	45	import org.eclipse.persistence.internal.oxm.MappingNodeValue;
47	import org.eclipse.persistence.internal.oxm.MediaType;
48	import org.eclipse.persistence.internal.oxm.NamespaceResolver;	46	import org.eclipse.persistence.internal.oxm.NamespaceResolver;
49	import org.eclipse.persistence.internal.oxm.NodeValue;	47	import org.eclipse.persistence.internal.oxm.NodeValue;
50	import org.eclipse.persistence.internal.oxm.Root;	48	import org.eclipse.persistence.internal.oxm.Root;
51	import org.eclipse.persistence.internal.oxm.Unmarshaller;	49	import org.eclipse.persistence.internal.oxm.Unmarshaller;
52	import org.eclipse.persistence.internal.oxm.XPathFragment;	50	import org.eclipse.persistence.internal.oxm.XPathFragment;
53	import org.eclipse.persistence.internal.oxm.mappings.Field;
54	import org.eclipse.persistence.internal.oxm.record.AbstractUnmarshalRecord;
55	import org.eclipse.persistence.internal.oxm.record.SAXUnmarshallerHandler;	51	import org.eclipse.persistence.internal.oxm.record.SAXUnmarshallerHandler;
56	import org.eclipse.persistence.internal.oxm.record.UnmarshalRecord;	52	import org.eclipse.persistence.internal.oxm.record.UnmarshalRecord;
57	import org.eclipse.persistence.internal.oxm.XPathNode;	53	import org.eclipse.persistence.internal.oxm.XPathNode;
58	import org.eclipse.persistence.internal.oxm.record.XMLReaderAdapter;
59	import org.eclipse.persistence.internal.oxm.record.deferred.DeferredContentHandler;	54	import org.eclipse.persistence.internal.oxm.record.deferred.DeferredContentHandler;
60	import org.eclipse.persistence.oxm.mappings.nullpolicy.AbstractNullPolicy;
61	import org.eclipse.persistence.oxm.record.XMLRootRecord;	55	import org.eclipse.persistence.oxm.record.XMLRootRecord;
62	import org.xml.sax.ErrorHandler;
63	import org.xml.sax.InputSource;	56	import org.xml.sax.InputSource;
64	import org.xml.sax.SAXException;	57	import org.xml.sax.SAXException;
65	import org.xml.sax.helpers.AttributesImpl;	58	import org.xml.sax.helpers.AttributesImpl;
66		59
67	public class JsonStructureReader extends XMLReaderAdapter {	60	public class JsonStructureReader extends JsonPReader {
68		61
69	private static final String TRUE = "true";
70	private static final String FALSE = "false";
71	private String attributePrefix = null;
72	private NamespaceResolver namespaces = null;
73	private boolean includeRoot;
74	private String textWrapper;
75	private Class unmarshalClass;
76	private boolean isInCollection;
77	private JsonStructure jsonStructure;	62	private JsonStructure jsonStructure;
78	private JsonAttributes attributes = new JsonAttributes();	63	private JsonAttributes attributes = new JsonAttributes();
79		64
80
81	public JsonStructureReader(Unmarshaller u) {	65	public JsonStructureReader(Unmarshaller u) {
82	this(u, null);	66	this(u, null);
83	}	67	}
84		68
85	public JsonStructureReader(Unmarshaller u, Class clazz) {	69	public JsonStructureReader(Unmarshaller u, Class clazz) {
86	this(u.getAttributePrefix(), u.getNamespaceResolver(), u.getNamespaceResolver() != null, u.isIncludeRoot(), u.getNamespaceSeparator(), u.getErrorHandler(), u.getValueWrapper(), clazz);	70	super(u.getAttributePrefix(), u.getNamespaceResolver(), u.getNamespaceResolver() != null, u.isIncludeRoot(), u.getNamespaceSeparator(), u.getErrorHandler(), u.getValueWrapper(), clazz);
87	}
88
89	private JsonStructureReader(String attrPrefix, NamespaceResolver nr,boolean namespaceAware, boolean includeRoot,Character namespaceSeparator, ErrorHandler errorHandler, String textWrapper, Class unmarshalClass) {
90	this.attributePrefix = attrPrefix;
91	if (attributePrefix == Constants.EMPTY_STRING) {
92	attributePrefix = null;
93	}
94	namespaces = nr;
95	this.namespaceAware = namespaceAware;
96	if (namespaceSeparator == null) {
97	this.namespaceSeparator = Constants.DOT;
98	} else {
99	this.namespaceSeparator = namespaceSeparator;
100	}
101	this.includeRoot = includeRoot;
102	this.setErrorHandler(errorHandler);
103	this.textWrapper = textWrapper;
104	this.unmarshalClass = unmarshalClass;
105	}	71	}
106
107		72
108	public void setJsonStructure(JsonStructure jsonStructure) {	73	public void setJsonStructure(JsonStructure jsonStructure) {
109	this.jsonStructure = jsonStructure;	74	this.jsonStructure = jsonStructure;
Lines 152-168 public class JsonStructureReader extends XMLReaderAdapter { Link Here
152	}	117	}
153	}	118	}
154		119
155	@Override
156	public void parse(String systemId) {
157	try {
158	parse(new InputSource(systemId));
159	} catch (IOException e) {
160	throw XMLMarshalException.unmarshalException(e);
161	} catch (SAXException e) {
162	throw XMLMarshalException.unmarshalException(e);
163	}
164	}
165
166	public void parseRoot(JsonValue jsonValue) throws SAXException {	120	public void parseRoot(JsonValue jsonValue) throws SAXException {
167	if (namespaces != null) {	121	if (namespaces != null) {
168	Map<String, String> namespacePairs = namespaces.getPrefixesToNamespaces();	122	Map<String, String> namespacePairs = namespaces.getPrefixesToNamespaces();
Lines 453-526 public class JsonStructureReader extends XMLReaderAdapter { Link Here
453		407
454	}	408	}
455		409
456	public boolean isNullRepresentedByXsiNil(AbstractNullPolicy nullPolicy) {
457	return true;
458	}
459
460	private void startCollection() {
461	isInCollection = true;
462	}
463
464	private void endCollection() {
465	isInCollection = false;
466	}
467
468	public boolean isInCollection() {
469	return isInCollection;
470	}
471
472	private boolean isTextValue(String localName) {
473	XPathNode currentNode = ((UnmarshalRecord) contentHandler).getXPathNode();
474	if (currentNode == null) {
475	return textWrapper != null && textWrapper.equals(localName);
476	}
477
478	return ((currentNode.getNonAttributeChildrenMap() == null \|\| currentNode.getNonAttributeChildrenMap().size() == 0 \|\| (currentNode.getNonAttributeChildrenMap().size() == 1 && currentNode.getTextNode() != null))&& textWrapper != null && textWrapper.equals(localName));
479	}
480
481	@Override
482	public Object convertValueBasedOnSchemaType(Field xmlField, Object value, ConversionManager conversionManager, AbstractUnmarshalRecord record) {
483	if (xmlField.getSchemaType() != null) {
484	if (Constants.QNAME_QNAME.equals(xmlField.getSchemaType())) {
485	String stringValue = (String) value;
486	int indexOpen = stringValue.indexOf('{');
487	int indexClose = stringValue.indexOf('}');
488	String uri = null;
489	String localName = null;
490	if (indexOpen > -1 && indexClose > -1) {
491	uri = stringValue.substring(indexOpen + 1, indexClose);
492	localName = stringValue.substring(indexClose + 1);
493	} else {
494	QName obj = (QName) xmlField.convertValueBasedOnSchemaType(stringValue, conversionManager, record);
495	localName = obj.getLocalPart();
496	uri = obj.getNamespaceURI();
497	}
498	if (uri != null) {
499	return new QName(uri, localName);
500	} else {
501	return new QName(localName);
502	}
503	} else {
504	Class fieldType = xmlField.getType();
505	if (fieldType == null) {
506	fieldType = xmlField.getJavaClass(xmlField.getSchemaType());
507	}
508	return conversionManager.convertObject(value, fieldType, xmlField.getSchemaType());
509	}
510	}
511	return value;
512	}
513
514	/**
515	* INTERNAL: The MediaType associated with this reader
516	*
517	* @return
518	*/
519	@Override
520	public MediaType getMediaType() {
521	return Constants.APPLICATION_JSON;
522	}
523
524	private static class JsonAttributes extends IndexedAttributeList {	410	private static class JsonAttributes extends IndexedAttributeList {
525		411
526	private JsonValue value;	412	private JsonValue value;

Lines 59-62 public class EscapeCharactersTestCases extends JSONMarshalUnmarshalTestCases { Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/EscapeCharactersTestCases.java (+16 lines)
59	return holder;	59	return holder;
60	}	60	}
61		61
		62	protected void compareStrings(String test, String testString, String expectedString, boolean removeWhitespace) {
		63	log(test);
		64	log("Expected (With All Whitespace Removed):");
		65	if(removeWhitespace){
		66	expectedString = expectedString.replaceAll("[ \b\t\n\r ]", "");
		67	}
		68	log(expectedString);
		69
		70	log("\nActual (With All Whitespace Removed):");
		71	if(removeWhitespace){
		72	testString = testString.replaceAll("[ \b\t\n\r]", "");
		73	}
		74	log(testString);
		75	assertEquals(expectedString.toLowerCase(), testString.toLowerCase());
		76	}
		77
62	}	78	}

Lines 86-91 public class XmlVariableNodeNullValueTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java (+11 lines)
86	fail("An XMLMarshalException should have occurred");	86	fail("An XMLMarshalException should have occurred");
87	}	87	}
88		88
		89	public void testJSONMarshalToBuilderResult() throws Exception{
		90	try{
		91	super.testJSONMarshalToBuilderResult();
		92	}catch(JAXBException e){
		93	if(verifyException(e)){
		94	return;
		95	}
		96	}
		97	fail("An XMLMarshalException should have occurred");
		98	}
		99
89	public void testJSONMarshalToStringWriter_FORMATTED() throws Exception{	100	public void testJSONMarshalToStringWriter_FORMATTED() throws Exception{
90	try{	101	try{
91	super.testJSONMarshalToStringWriter_FORMATTED();	102	super.testJSONMarshalToStringWriter_FORMATTED();