Attachment 232906 Details for Bug 411377 – Work in progress

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

[patch] Work in progress

bug411377_trunk.patch (text/plain), 42.80 KB, created by Denise Smith

on 2013-06-28 16:07:22 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Denise Smith

Created: 2013-06-28 16:07:22 EDT

Size: 42.80 KB

patch

obsolete

> .../persistence/internal/oxm/XMLMarshaller.java    |   5 +-
> .../internal/oxm/record/ExtendedResult.java        |  32 +
> .../oxm/record/json/JsonStructureReader.java       | 118 +---
> .../oxm/json/JsonArrayBuilderResult.java           |  39 ++
> .../oxm/json/JsonObjectBuilderResult.java          |  38 ++
> .../oxm/record/JsonObjectBuilderWriterRecord.java  | 743 +++++++++++++++++++++
> .../testing/jaxb/JAXBWithJSONTestCases.java        |  61 ++
> moxy/org.eclipse.persistence.moxy/.classpath       |   2 +-
> 16 files changed, 949 insertions(+), 126 deletions(-)
>
>
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>index 7cc9b53..d1dafb0 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>@@ -41,6 +41,7 @@ import org.eclipse.persistence.internal.core.sessions.CoreAbstractSession;
> import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
> import org.eclipse.persistence.internal.oxm.mappings.Field;
> import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;
>+import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
> import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;
> import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
> import org.eclipse.persistence.oxm.JSONWithPadding;
>@@ -1009,7 +1010,9 @@ public abstract class XMLMarshaller<
>         } else if (result instanceof SAXResult) {
>             SAXResult saxResult = (SAXResult) result;
>             marshal(object, saxResult.getHandler());
>-        } else {
>+        } else if (result instanceof ExtendedResult){           
>+            marshal(object, ((ExtendedResult)result).createRecord(), session, xmlDescriptor, isXMLRoot);
>+        }else {
>             if (result.getClass().equals(staxResultClass)) {
>                 try {
>                     Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java
>new file mode 100644
>index 0000000..eaaa1df
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java
>@@ -0,0 +1,32 @@
>+/*******************************************************************************
>+ * 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;
>+    }
>+}
>
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java
>new file mode 100644
>index 0000000..40e538a
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java
>@@ -0,0 +1,39 @@
>+/*******************************************************************************
>+ * 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;
>+    }
>+
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java
>new file mode 100644
>index 0000000..ed77be0
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java
>@@ -0,0 +1,38 @@
>+/*******************************************************************************
>+ * 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;
>+    }
>+
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java
>new file mode 100644
>index 0000000..19b2d75
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java
>@@ -0,0 +1,743 @@
>+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;
>+        }
>+    }
>+
>+
>+}
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>index 7d9356e..034e4b6 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>@@ -23,8 +23,13 @@ import java.util.ArrayList;
> import java.util.List;
> 
> import javax.json.Json;
>+import javax.json.JsonObject;
>+import javax.json.JsonObjectBuilder;
> import javax.json.JsonReader;
> import javax.json.JsonStructure;
>+import javax.json.JsonWriter;
>+import javax.json.stream.JsonGenerator;
>+import javax.json.stream.JsonParser;
> import javax.xml.bind.JAXBElement;
> import javax.xml.bind.Marshaller;
> import javax.xml.bind.Unmarshaller;
>@@ -37,6 +42,9 @@ import org.eclipse.persistence.jaxb.JAXBContext;
> import org.eclipse.persistence.jaxb.MarshallerProperties;
> import org.eclipse.persistence.jaxb.UnmarshallerProperties;
> import org.eclipse.persistence.oxm.MediaType;
>+import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
>+import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
>+import org.eclipse.persistence.oxm.json.JsonParserSource;
> import org.eclipse.persistence.oxm.json.JsonStructureSource;
> import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
> import org.xml.sax.InputSource;
>@@ -235,6 +243,25 @@ public abstract class JAXBWithJSONTestCases extends JAXBTestCases {
>             jsonToObjectTest(testObject);
>         }
>     }
>+    
>+    //200 failures? doesn't handle attributes
>+   /* public void testJSONUnmarshalFromJsonParserSource() throws Exception {
>+        if(isUnmarshalTest()){
>+            getJSONUnmarshaller().setProperty(UnmarshallerProperties.MEDIA_TYPE, getJSONUnmarshalMediaType());
>+           InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);    
>+           JsonParser parser = Json.createParser(inputStream);
>+           JsonParserSource source = new JsonParserSource(parser);
>+            
>+            Object testObject = null;
>+            if(getUnmarshalClass() != null){               
>+                testObject = getJSONUnmarshaller().unmarshal(source, getUnmarshalClass());
>+            }else{
>+                testObject = getJSONUnmarshaller().unmarshal(source);
>+            }
>+            jsonToObjectTest(testObject);
>+        }
>+    }
>+*/
>        
>     public void testJSONUnmarshalFromURL() throws Exception {
>     	if(isUnmarshalTest()){
>@@ -290,6 +317,40 @@ public abstract class JAXBWithJSONTestCases extends JAXBTestCases {
>         compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
>     }
> 
>+  /*  public void testJSONMarshalToJsonGeneratorResult() throws Exception{
>+        getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
>+
>+        StringWriter sw = new StringWriter();
>+        JsonGenerator generator = Json.createGenerator(sw);
>+        JsonGeneratorResult result = new JsonGeneratorResult(generator);
>+        getJSONMarshaller().marshal(getWriteControlObject(), result);
>+        generator.flush();
>+        log(sw.toString());
>+        compareStringToControlFile("**testJSONMarshalToStringWriter**", sw.toString());
>+    }
>+    */
>+    
>+    public void testJSONMarshalToBuilderResult() throws Exception{
>+        getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
>+
>+        JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
>+       // JsonGenerator generator = Json.createGenerator(sw);
>+        JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
>+        getJSONMarshaller().marshal(getWriteControlObject(), result);
>+        //generator.flush();
>+        JsonObject jsonObject = jsonObjectBuilder.build();
>+        
>+        StringWriter sw = new StringWriter();
>+        JsonWriter writer= Json.createWriter(sw);
>+        //writer.write(rootStructure);
>+        writer.writeObject(jsonObject);
>+        writer.close();
>+        System.out.println(sw.toString());
>+        
>+        log(sw.toString());
>+        compareStringToControlFile("**testJSONMarshalToStringWriter**", sw.toString());
>+    }
>+    
>     protected void compareStringToControlFile(String test, String testString) {
>     	compareStringToControlFile(test, testString, getWriteControlJSON());
>     }
>

Actions: View | Diff

Attachments on bug 411377: 232906 | 233631 | 233635 | 233675 | 233682 | 233709 | 233732 | 233733