Attachment #232906 for bug #411377

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




/*******************************************************************************
 * 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;
    }
}




/*******************************************************************************
 * 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.JsonArrayBuilder;
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 JsonArrayBuilderResult extends ExtendedResult{

    private JsonArrayBuilder jsonArrayBuilder;
        
    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.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(JsonObjectBuilder jsonObjectBuilder){
        this.jsonObjectBuilder = jsonObjectBuilder;
    }

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

    public JsonObjectBuilder getJsonObjectBuilder() {
        return jsonObjectBuilder;
    }

}




package org.eclipse.persistence.oxm.record;

import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Stack;

import javax.json.Json;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObjectBuilder;
import javax.xml.namespace.QName;

import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.oxm.Constants;
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.XMLConversionManager;
import org.eclipse.persistence.internal.oxm.XMLMarshaller;
import org.eclipse.persistence.internal.oxm.XPathFragment;
import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
import org.eclipse.persistence.oxm.record.JsonObjectBuilderWriterRecord2.Level;
import org.w3c.dom.Node;


//TODO characterescapehandler
//TODO encoder
//TODO is isRootArray needeD
//TODO replace NULL string with addNUll

public class JsonObjectBuilderWriterRecord extends MarshalRecord <XMLMarshaller> {

    protected Stack<Level> levels = new Stack<Level>();
    private JsonObjectBuilder rootJsonObjectBuilder;
    private JsonArrayBuilder rootJsonArrayBuilder;
    protected String attributePrefix;
    protected boolean charactersAllowed = false;
    private boolean isRootArray;
    protected static final String NULL="null";
    private boolean lastEventWasStart;
    
    public JsonObjectBuilderWriterRecord(){
        super();
    }
    
    public JsonObjectBuilderWriterRecord(JsonObjectBuilder jsonObjectBuilder){
        this();
        this.rootJsonObjectBuilder = jsonObjectBuilder;
    }
    
    public JsonObjectBuilderWriterRecord(JsonArrayBuilder jsonArrayBuilder){
        this();
        this.rootJsonArrayBuilder = jsonArrayBuilder;
    }
    
    /**
     * INTERNAL:
     */
    public void setMarshaller(XMLMarshaller marshaller) {
        super.setMarshaller(marshaller);
        attributePrefix = marshaller.getAttributePrefix();
       // encoder = Charset.forName(marshaller.getEncoding()).newEncoder();
        if (marshaller.getValueWrapper() != null) {
            textWrapperFragment = new XPathFragment();
            textWrapperFragment.setLocalName(marshaller.getValueWrapper());
        }
       // characterEscapeHandler = marshaller.getCharacterEscapeHandler();
    }
    
    @Override
    public void startDocument(String encoding, String version) {
        /*if(!levels.isEmpty()) {
            Level level = levels.peek();
            if(level.isFirst()) {
                level.setFirst(false);
            } 
        }*/
        Level rootLevel = new Level();
        if(rootJsonObjectBuilder == null){
            rootJsonObjectBuilder = Json.createObjectBuilder();
        }
        rootLevel.setJsonObjectBuilder(rootJsonObjectBuilder);             
        levels.push(rootLevel);
        
    }

    @Override
    public void endDocument() {
        //levels.pop();        
    }

    public void startCollection() {
        if(levels.isEmpty()) {           
             isRootArray = true;              
             Level rootLevel = new Level(true);
             if(rootJsonArrayBuilder == null){
                  rootJsonArrayBuilder = Json.createArrayBuilder();
             }
             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
             levels.push(rootLevel);                      
        } else {
            Level level = new Level(true);            
            level.setJsonArrayBuilder(Json.createArrayBuilder());
            level.setFirstInCollection(true);
            levels.push(level);
        }
        lastEventWasStart = false;
        /*else {
        //    levels.peek().setCollection(true);
          //  levels.peek().setEmptyCollection(true);
            
            //newLevel.setJsonArrayBuilder(Json.createArrayBuilder());
            Level newLevel = new Level(true, false);
            newLevel.setCollection(true);
            newLevel.setEmptyCollection(true);
            newLevel.setJsonArrayBuilder(Json.createArrayBuilder());
            levels.push(newLevel);
        }*/
    }
    
    @Override
    public void endCollection() {
       /* if(levels.size() == 1) {
            levels.pop();
         } else{
             
         }*/        
         Level position = levels.pop();
         Level parent = levels.peek();
         if(parent.isCollection){
             parent.getJsonArrayBuilder().add(position.getJsonArrayBuilder());
         }else{
             if(parent.getJsonObjectBuilder() == null){
                 parent.setJsonObjectBuilder(Json.createObjectBuilder());
             }
             parent.getJsonObjectBuilder().add(position.keyName, position.getJsonArrayBuilder());
         }
         lastEventWasStart = false;
         
           /* if(levels.size() == 1) {
             //   writer.write(']');
            } else {
               Level position = levels.peek();
               Level parent = levels.get(levels.size()-2);
               if(position != null && position.isCollection() && !position.isEmptyCollection()) {
                   parent.jsonObjectBuilder.add(position.keyName, position.getJsonArrayBuilder());
               }
                Level position = levels.pop();
                Level parent = levels.peek();
                if(position != null && position.isCollection() && !position.isEmptyCollection()) {
                    //writer.write(']');
                    //Level parent = levels.get(1);
                   parent.jsonObjectBuilder.add(position.keyName, position.getJsonArrayBuilder());  
                   parent.needToOpenComplex = false;
                   parent.needToCloseComplex = true;
                }  
                
                position.setCollection(false);
            }
            levels.peek().setCollection(false);
       */
    }
    
    @Override    
    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
        
                
        if(levels.isEmpty()) {
            //TODO when does this happen?
        //    newLevel = new Level();
          //  newLevel.setJsonObjectBuilder(Json.createObjectBuilder());
            //levels.push(newLevel);
         } else {
            Level position = levels.peek();
            Level newLevel;
            //if(position.isCollection && position.isEmptyCollection() && !lastEventWasStart){
            if(position.isCollection && !lastEventWasStart){
                 newLevel = position;      
                 position.setEmptyCollection(false);
            }else{
                newLevel = new Level();  
                levels.push(newLevel);                
            }
            if(lastEventWasStart){
                //newLevel.setComplex(true);
                if(position.isCollection){
                    newLevel.setJsonObjectBuilder(Json.createObjectBuilder());    
                }else{
                position.setJsonObjectBuilder(Json.createObjectBuilder());
                }
            }
            
            //if(position.isCollection){
            //    newLevel.setCollection(true);
              //  newLevel.setJsonArrayBuilder(position.getJsonArrayBuilder());
           // }
            
            String keyName = getKeyName(xPathFragment);
            newLevel.setKeyName(keyName);
         }
        //if(!charactersAllowed){
            //complex??
      //  }
        charactersAllowed = true;
        lastEventWasStart = true;
    }
    
    protected String getKeyName(XPathFragment xPathFragment){
        super.openStartElement(xPathFragment, namespaceResolver);
        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);
        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) {
        // TODO Auto-generated method stub
        
    }
    
    /**
     * 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) {
                startCollection();
                if (!xPathFragment.isSelfFragment()) {
                    openStartElement(xPathFragment, namespaceResolver);
                    if (!levels.isEmpty()) {
                        Level position = levels.peek();
                     //   position.setNeedToCloseComplex(false);
                      //  position.setNeedToOpenComplex(false);
                    }
                    endElement(xPathFragment, namespaceResolver);
                }
                endCollection();
                //endEmptyCollection();
            }
             return true;
         }else{
             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
         }
    }

    @Override
    public void attribute(XPathFragment xPathFragment,
            NamespaceResolver namespaceResolver, String value) {
        // TODO Auto-generated method stub
        
    }

    @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);
        writeValue(value, null);
        endElement(xPathFragment, namespaceResolver);
        
    }

    @Override
    public void closeStartElement() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
        if(!levels.isEmpty()) {
            Level position = levels.peek();
            if(position.isCollection){// && position.isFirstInCollection()){                
                return;
            }
            position = levels.pop();
            //if(position.isCollection && position.isFirstInCollection ||
            // if(!position.isFinished() || position.getJsonObjectBuilder() != null){
            if(!position.isFinished() ){
                Level parent = levels.peek();
                if(parent.isCollection){
                    position.setEmptyCollection(false);
                    if(parent.getJsonArrayBuilder() == null){
                        parent.setJsonArrayBuilder(Json.createArrayBuilder());
                    }
                    if(position.isCollection){
                       parent.getJsonArrayBuilder().add(position.getJsonArrayBuilder());
                    }else{
                        parent.getJsonArrayBuilder().add(position.getJsonObjectBuilder()); 
                    }
                }else{
                    if(parent.getJsonObjectBuilder() == null){
                        parent.setJsonObjectBuilder(Json.createObjectBuilder());
                    }
                    if(position.isCollection){
                        parent.getJsonObjectBuilder().add(position.keyName,position.getJsonArrayBuilder());
                     }else{
                         parent.getJsonObjectBuilder().add(position.keyName,position.getJsonObjectBuilder()); 
                     }
                }
                
            }
        }
        lastEventWasStart = false;
    }

    @Override
    public void characters(String value) {
        writeValue(value, null);
    }
    
    @Override
    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA){          
        Level position = levels.peek();
        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);
            //characters((String)convertedValue);
            writeValue(convertedValue, null);
        } else {
            writeValue(value, schemaType);        
        }
    }
    
    public void writeValue(Object value, QName schemaType) {
        Level position = levels.peek();
     //   Level parent = levels.get(levels.size() -2);        
        boolean textWrapperOpened = false;
        if(!charactersAllowed){    
             if(textWrapperFragment != null){
                 openStartElement(textWrapperFragment, namespaceResolver);
                 textWrapperOpened = true;
             }
        }
        
        if(position.isCollection()){
            position.setEmptyCollection(false);
            if(value == NULL){
                position.getJsonArrayBuilder().addNull();
            }else if(value instanceof Integer){
                position.getJsonArrayBuilder().add((Integer)value);  
            }else if(value instanceof BigDecimal){
                position.getJsonArrayBuilder().add((BigDecimal)value);   
            }else if(value instanceof BigInteger){
                position.getJsonArrayBuilder().add((BigInteger)value);               
            }else if(value instanceof Boolean){
                position.getJsonArrayBuilder().add((Boolean)value);
            }else if(value instanceof Double){
                position.getJsonArrayBuilder().add((Double)value);
            }else if(value instanceof Long){
                position.getJsonArrayBuilder().add((Long)value);
            }else if(value instanceof String){
                position.getJsonArrayBuilder().add((String)value);
            }else{
                String convertedValue = ((String) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.STRING, schemaType));
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
                if((schemaType == null || theClass == null) && (ClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                    //if it's still a number and falls through the cracks we dont want "" around the value
                        BigDecimal convertedNumberValue = ((BigDecimal) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.BIGDECIMAL, schemaType));
                        position.getJsonArrayBuilder().add((BigDecimal)convertedNumberValue);
                }else{
                    position.getJsonArrayBuilder().add(convertedValue);
                }
            }
            
        }
        
        /*
        if(parent.isCollection()){
            parent.setEmptyCollection(false);
            if(value == NULL){
                parent.getJsonArrayBuilder().addNull();
            }else if(value instanceof Integer){
                parent.getJsonArrayBuilder().add((Integer)value);  
            }else if(value instanceof BigDecimal){
                parent.getJsonArrayBuilder().add((BigDecimal)value);   
            }else if(value instanceof BigInteger){
                parent.getJsonArrayBuilder().add((BigInteger)value);               
            }else if(value instanceof Boolean){
                parent.getJsonArrayBuilder().add((Boolean)value);
            }else if(value instanceof Double){
                parent.getJsonArrayBuilder().add((Double)value);
            }else if(value instanceof Long){
                parent.getJsonArrayBuilder().add((Long)value);
            }else if(value instanceof String){
                parent.getJsonArrayBuilder().add((String)value);
            }else{
                String convertedValue = ((String) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.STRING, schemaType));
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
                if((schemaType == null || theClass == null) && (ClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                    //if it's still a number and falls through the cracks we dont want "" around the value
                        BigDecimal convertedNumberValue = ((BigDecimal) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.BIGDECIMAL, schemaType));
                        parent.getJsonArrayBuilder().add((BigDecimal)convertedNumberValue);
                }else{
                    parent.getJsonArrayBuilder().add(convertedValue);
                }
            }
            
        }*/
       /* if(parent.isCollection){
            position.setCollection(true);
            position.setJsonArrayBuilder(parent.jsonArrayBuilder);
        }
       
        if(position.isCollection()){
            position.setEmptyCollection(false);
            if(value == NULL){
                position.getJsonArrayBuilder().addNull();
            }else if(value instanceof Integer){
                position.getJsonArrayBuilder().add((Integer)value);  
            }else if(value instanceof BigDecimal){
                position.getJsonArrayBuilder().add((BigDecimal)value);   
            }else if(value instanceof BigInteger){
                position.getJsonArrayBuilder().add((BigInteger)value);               
            }else if(value instanceof Boolean){
                position.getJsonArrayBuilder().add((Boolean)value);
            }else if(value instanceof Double){
                position.getJsonArrayBuilder().add((Double)value);
            }else if(value instanceof Long){
                position.getJsonArrayBuilder().add((Long)value);
            }else if(value instanceof String){
                position.getJsonArrayBuilder().add((String)value);
            }else{
                String convertedValue = ((String) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.STRING, schemaType));
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
                if((schemaType == null || theClass == null) && (ClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                    //if it's still a number and falls through the cracks we dont want "" around the value
                        BigDecimal convertedNumberValue = ((BigDecimal) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.BIGDECIMAL, schemaType));
                        position.getJsonArrayBuilder().add((BigDecimal)convertedNumberValue);
                }else{
                    position.getJsonArrayBuilder().add(convertedValue);
                }
            }
            
        }
        */
        else{
            //Level parent = levels.get(levels.size() -2);
            //JsonObjectBuilder builder = parent.getJsonObjectBuilder();
            
            JsonObjectBuilder builder = position.getJsonObjectBuilder();           
            if(builder == null){
                Level parent = levels.get(levels.size() -2);
                builder = parent.getJsonObjectBuilder();
            }
               
            
                
            /*
            if(!parent.isCollection && parent.getJsonObjectBuilder() == null){
                parent.setJsonObjectBuilder(Json.createObjectBuilder());   
            }*/
            
            if(value == NULL){
                builder.addNull(position.keyName);
            }else if(value instanceof Integer){
                builder.add(position.keyName, (Integer)value);  
            }else if(value instanceof BigDecimal){
                builder.add(position.keyName, (BigDecimal)value);   
            }else if(value instanceof BigInteger){
                builder.add(position.keyName, (BigInteger)value);               
            }else if(value instanceof Boolean){
                builder.add(position.keyName, (Boolean)value);
            }else if(value instanceof Double){
                builder.add(position.keyName, (Double)value);
            }else if(value instanceof Long){
                builder.add(position.keyName, (Long)value);
            }else if(value instanceof String){
                builder.add(position.keyName, (String)value);
            }else{
                String convertedValue = ((String) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.STRING, schemaType));
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
                if((schemaType == null || theClass == null) && (ClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                    //if it's still a number and falls through the cracks we dont want "" around the value
                        BigDecimal convertedNumberValue = ((BigDecimal) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, ClassConstants.BIGDECIMAL, schemaType));
                        builder.add(position.keyName, (BigDecimal)convertedNumberValue);
                }else{
                    builder.add(position.keyName, convertedValue);
                }
                    
            }
        }
        if(textWrapperOpened){    
            if(textWrapperFragment != null){
                endElement(textWrapperFragment, namespaceResolver);
            }
        }
        position.setFinished(true);
        charactersAllowed = false;
        lastEventWasStart = false;

    }

    @Override
    public void cdata(String value) {
        characters(value);        
    }

    @Override
    public void node(Node node, NamespaceResolver resolver,
            String qualifiedName, String rootUri) {
        // TODO Auto-generated method stub
        
    }        
    
    protected String getStringForQName(QName qName){
        if(null == qName) {
            return null;
        }
        XMLConversionManager xmlConversionManager = (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);
     }
    
    /**
     * 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 boolean finished;
        private JsonObjectBuilder jsonObjectBuilder;
        private JsonArrayBuilder jsonArrayBuilder;
        private boolean isFirstInCollection;
        private boolean isComplex;
        
        public Level(){
            
        }
        
        public Level(boolean isCollection) {
            this.isCollection = isCollection;
            this.emptyCollection = true;
        }

        public boolean isCollection() {
            return isCollection;
        }

        public void setCollection(boolean isCollection) {
            this.isCollection = isCollection;
        }

        public String getKeyName() {
            return keyName;
        }

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

        public 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 isFinished() {
            return finished;
        }

        public void setFinished(boolean finished) {
            this.finished = finished;
        }

        public boolean isFirstInCollection() {
            return isFirstInCollection;
        }

        public void setFirstInCollection(boolean isFirstInCollection) {
            this.isFirstInCollection = isFirstInCollection;
        }

        public boolean isComplex() {
            return isComplex;
        }

        public void setComplex(boolean isComplex) {
            this.isComplex = isComplex;
        }
    }


}

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

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java (+61 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.JsonGenerator;
		32	import javax.json.stream.JsonParser;
28	import javax.xml.bind.JAXBElement;	33	import javax.xml.bind.JAXBElement;
29	import javax.xml.bind.Marshaller;	34	import javax.xml.bind.Marshaller;
30	import javax.xml.bind.Unmarshaller;	35	import javax.xml.bind.Unmarshaller;
Lines 37-42 import org.eclipse.persistence.jaxb.JAXBContext; Link Here
37	import org.eclipse.persistence.jaxb.MarshallerProperties;	42	import org.eclipse.persistence.jaxb.MarshallerProperties;
38	import org.eclipse.persistence.jaxb.UnmarshallerProperties;	43	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
39	import org.eclipse.persistence.oxm.MediaType;	44	import org.eclipse.persistence.oxm.MediaType;
		45	import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
		46	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
		47	import org.eclipse.persistence.oxm.json.JsonParserSource;
40	import org.eclipse.persistence.oxm.json.JsonStructureSource;	48	import org.eclipse.persistence.oxm.json.JsonStructureSource;
41	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;	49	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
42	import org.xml.sax.InputSource;	50	import org.xml.sax.InputSource;
Lines 235-240 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
235	jsonToObjectTest(testObject);	243	jsonToObjectTest(testObject);
236	}	244	}
237	}	245	}
		246
		247	//200 failures? doesn't handle attributes
		248	/* public void testJSONUnmarshalFromJsonParserSource() throws Exception {
		249	if(isUnmarshalTest()){
		250	getJSONUnmarshaller().setProperty(UnmarshallerProperties.MEDIA_TYPE, getJSONUnmarshalMediaType());
		251	InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);
		252	JsonParser parser = Json.createParser(inputStream);
		253	JsonParserSource source = new JsonParserSource(parser);
		254
		255	Object testObject = null;
		256	if(getUnmarshalClass() != null){
		257	testObject = getJSONUnmarshaller().unmarshal(source, getUnmarshalClass());
		258	}else{
		259	testObject = getJSONUnmarshaller().unmarshal(source);
		260	}
		261	jsonToObjectTest(testObject);
		262	}
		263	}
		264	*/
238		265
239	public void testJSONUnmarshalFromURL() throws Exception {	266	public void testJSONUnmarshalFromURL() throws Exception {
240	if(isUnmarshalTest()){	267	if(isUnmarshalTest()){
Lines 290-295 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
290	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());	317	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
291	}	318	}
292		319
		320	/* public void testJSONMarshalToJsonGeneratorResult() throws Exception{
		321	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
		322
		323	StringWriter sw = new StringWriter();
		324	JsonGenerator generator = Json.createGenerator(sw);
		325	JsonGeneratorResult result = new JsonGeneratorResult(generator);
		326	getJSONMarshaller().marshal(getWriteControlObject(), result);
		327	generator.flush();
		328	log(sw.toString());
		329	compareStringToControlFile("testJSONMarshalToStringWriter", sw.toString());
		330	}
		331	*/
		332
		333	public void testJSONMarshalToBuilderResult() throws Exception{
		334	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
		335
		336	JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
		337	// JsonGenerator generator = Json.createGenerator(sw);
		338	JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
		339	getJSONMarshaller().marshal(getWriteControlObject(), result);
		340	//generator.flush();
		341	JsonObject jsonObject = jsonObjectBuilder.build();
		342
		343	StringWriter sw = new StringWriter();
		344	JsonWriter writer= Json.createWriter(sw);
		345	//writer.write(rootStructure);
		346	writer.writeObject(jsonObject);
		347	writer.close();
		348	System.out.println(sw.toString());
		349
		350	log(sw.toString());
		351	compareStringToControlFile("testJSONMarshalToStringWriter", sw.toString());
		352	}
		353
293	protected void compareStringToControlFile(String test, String testString) {	354	protected void compareStringToControlFile(String test, String testString) {
294	compareStringToControlFile(test, testString, getWriteControlJSON());	355	compareStringToControlFile(test, testString, getWriteControlJSON());
295	}	356	}

Return to bug 411377

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