Attachment #233635 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.internal.oxm.record.MarshalRecord;
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.IOException;
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 21-27 import java.util.Stack; Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java (-6 / +9 lines)
21		21
22	import javax.xml.namespace.QName;	22	import javax.xml.namespace.QName;
23		23
24	import org.eclipse.persistence.exceptions.JAXBException;
25	import org.eclipse.persistence.exceptions.XMLMarshalException;	24	import org.eclipse.persistence.exceptions.XMLMarshalException;
26	import org.eclipse.persistence.internal.core.helper.CoreClassConstants;	25	import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
27	import org.eclipse.persistence.internal.core.helper.CoreConversionManager;	26	import org.eclipse.persistence.internal.core.helper.CoreConversionManager;
Lines 237-246 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here
237	}	236	}
238	}	237	}
239	if(xPathFragment.nameIsText()){	238	if(xPathFragment.nameIsText()){
240	if(position != null && position.isCollection() && position.isEmptyCollection()) {	239	if(position != null && position.isCollection() && position.isEmptyCollection()) {
241	if(!charactersAllowed){
242	throw JAXBException.jsonValuePropertyRequired("[");
243	}
244	writer.write('[');	240	writer.write('[');
245	position.setEmptyCollection(false);	241	position.setEmptyCollection(false);
246	position.setNeedToOpenComplex(false);	242	position.setNeedToOpenComplex(false);
Lines 367-372 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here
367	} else {	363	} else {
368	levels.peek().setCollection(true);	364	levels.peek().setCollection(true);
369	levels.peek().setEmptyCollection(true);	365	levels.peek().setEmptyCollection(true);
		366	charactersAllowed = false;
		367	isStartElementOpen = false;
370	}	368	}
371	}	369	}
372		370
Lines 410-423 public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> { Link Here
410	*/	408	*/
411	public void characters(String value, boolean isString, boolean isAttribute) {	409	public void characters(String value, boolean isString, boolean isAttribute) {
412	boolean textWrapperOpened = false;	410	boolean textWrapperOpened = false;
		411	Level position = levels.peek();
413	if(!charactersAllowed){	412	if(!charactersAllowed){
414	if(textWrapperFragment != null){	413	if(textWrapperFragment != null){
		414	if(!isStartElementOpen && position.isFirst()){
		415	position.needToOpenComplex = true;
		416	position.needToOpenComplex = true;
		417	}
415	openStartElement(textWrapperFragment, namespaceResolver);	418	openStartElement(textWrapperFragment, namespaceResolver);
416	textWrapperOpened = true;	419	textWrapperOpened = true;
417	}	420	}
418	}	421	}
419		422
420	Level position = levels.peek();	423	position = levels.peek();
421	position.setNeedToOpenComplex(false);	424	position.setNeedToOpenComplex(false);
422	try {	425	try {
423	if(isString){	426	if(isString){




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);
            newLevel.setItemInCollection(true);
            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.isItemInCollection() && position.parentLevel != null){
                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(position.isCollection){
                newLevel.itemInCollection = true;            
            }            
          
            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 boolean itemInCollection;
        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();
            }
        }

        public boolean isItemInCollection() {
            return itemInCollection;
        }

        public void setItemInCollection(boolean itemInCollection) {
            this.itemInCollection = itemInCollection;
        }
    }


}

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 / +22 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	getJSONMarshaller().marshal(getWriteControlObject(), result);
		323	JsonObject jsonObject = jsonObjectBuilder.build();
		324
		325	StringWriter sw = new StringWriter();
		326	JsonWriter writer= Json.createWriter(sw);
		327	writer.writeObject(jsonObject);
		328	writer.close();
		329
		330	log(sw.toString());
		331	compareStringToControlFile("testJSONMarshalToStringWriter", sw.toString());
		332	}
312		333
313	protected void compareStringToControlFile(String test, String testString) {	334	protected void compareStringToControlFile(String test, String testString) {
314	compareStringToControlFile(test, testString, getWriteControlJSON());	335	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();

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 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

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 15-21 package org.eclipse.persistence.oxm.record; Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONFormattedWriterRecord.java (-5 / +1 lines)
15	import java.io.IOException;	15	import java.io.IOException;
16	import java.io.Writer;	16	import java.io.Writer;
17		17
18	import org.eclipse.persistence.exceptions.JAXBException;
19	import org.eclipse.persistence.exceptions.XMLMarshalException;	18	import org.eclipse.persistence.exceptions.XMLMarshalException;
20	import org.eclipse.persistence.internal.oxm.Constants;	19	import org.eclipse.persistence.internal.oxm.Constants;
21	import org.eclipse.persistence.internal.oxm.NamespaceResolver;	20	import org.eclipse.persistence.internal.oxm.NamespaceResolver;
Lines 122-131 public class JSONFormattedWriterRecord extends JSONWriterRecord { Link Here
122	}	121	}
123	}	122	}
124	if(xPathFragment.nameIsText()){	123	if(xPathFragment.nameIsText()){
125	if(position != null && position.isCollection() && position.isEmptyCollection()) {	124	if(position != null && position.isCollection() && position.isEmptyCollection()) {
126	if(!charactersAllowed){
127	throw JAXBException.jsonValuePropertyRequired("[");
128	}
129	writer.write('[');	125	writer.write('[');
130	writer.write(' ');	126	writer.write(' ');
131	position.setEmptyCollection(false);	127	position.setEmptyCollection(false);

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();

Lines 42-47 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)
42	import org.eclipse.persistence.internal.oxm.mappings.Descriptor;	42	import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
43	import org.eclipse.persistence.internal.oxm.mappings.Field;	43	import org.eclipse.persistence.internal.oxm.mappings.Field;
44	import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;	44	import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;
		45	import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
45	import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;	46	import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;
46	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;	47	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
47	import org.eclipse.persistence.oxm.JSONWithPadding;	48	import org.eclipse.persistence.oxm.JSONWithPadding;
Lines 1014-1020 public abstract class XMLMarshaller< Link Here
1014	} else if (result instanceof SAXResult) {	1015	} else if (result instanceof SAXResult) {
1015	SAXResult saxResult = (SAXResult) result;	1016	SAXResult saxResult = (SAXResult) result;
1016	marshal(object, saxResult.getHandler());	1017	marshal(object, saxResult.getHandler());
1017	} else {	1018	} else if (result instanceof ExtendedResult){
		1019	marshal(object, ((ExtendedResult)result).createRecord(), session, xmlDescriptor, isXMLRoot);
		1020	}else {
1018	if (result.getClass().equals(staxResultClass)) {	1021	if (result.getClass().equals(staxResultClass)) {
1019	try {	1022	try {
1020	Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);	1023	Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);