Attachment 233733 Details for Bug 411377 – Additional update (rename)

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

[patch] Additional update (rename)

bug411377_trunk_update3.patch (text/plain), 72.40 KB, created by Denise Smith

on 2013-07-23 16:51:17 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Denise Smith

Created: 2013-07-23 16:51:17 EDT

Size: 72.40 KB

patch

obsolete

> .../oxm/json/JsonArrayBuilderResult.java           |   4 +-
> .../oxm/json/JsonObjectBuilderResult.java          |   4 +-
> .../persistence/oxm/record/JsonBuilderRecord.java  | 813 +++++++++++++++++++++
> .../oxm/record/JsonBuilderWriterRecord.java        | 813 ---------------------
> 11 files changed, 847 insertions(+), 830 deletions(-)
>
>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
>index 2a5c906..e830b9f 100644
>--- 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
>@@ -15,7 +15,7 @@ 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.JsonBuilderWriterRecord;
>+import org.eclipse.persistence.oxm.record.JsonBuilderRecord;
> 
> 
> public class JsonArrayBuilderResult extends ExtendedResult{
>@@ -32,7 +32,7 @@ public class JsonArrayBuilderResult extends ExtendedResult{
> 
>     @Override
>     public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
>-         return new JsonBuilderWriterRecord(jsonArrayBuilder);
>+         return new JsonBuilderRecord(jsonArrayBuilder);
>     }
> 
>     public JsonArrayBuilder getJsonArrayBuilder() {
>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
>index 7dcfb50..bb01b73 100644
>--- 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
>@@ -15,7 +15,7 @@ package org.eclipse.persistence.oxm.json;
> import javax.json.Json;
> import javax.json.JsonObjectBuilder;
> import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
>-import org.eclipse.persistence.oxm.record.JsonBuilderWriterRecord;
>+import org.eclipse.persistence.oxm.record.JsonBuilderRecord;
> 
> 
> public class JsonObjectBuilderResult extends ExtendedResult{
>@@ -32,7 +32,7 @@ public class JsonObjectBuilderResult extends ExtendedResult{
> 
>     @Override
>     public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
>-         return new JsonBuilderWriterRecord(jsonObjectBuilder);
>+         return new JsonBuilderRecord(jsonObjectBuilder);
>     }
> 
>     public JsonObjectBuilder getJsonObjectBuilder() {
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderRecord.java
>new file mode 100644
>index 0000000..5227b1c
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderRecord.java
>@@ -0,0 +1,813 @@
>+/*******************************************************************************
>+ * 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.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;
>+
>+public class JsonBuilderRecord 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 JsonBuilderRecord(){
>+        super();
>+        isLastEventStart = false;
>+    }
>+    
>+    public JsonBuilderRecord(JsonObjectBuilder jsonObjectBuilder){
>+        this();
>+        rootJsonObjectBuilder = jsonObjectBuilder;
>+    }
>+    
>+    public JsonBuilderRecord(JsonArrayBuilder jsonArrayBuilder){
>+        this();
>+        rootJsonArrayBuilder = jsonArrayBuilder;
>+        isRootArray = true;
>+    }
>+    
>+    /**
>+     * 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){
>+            if(position == null){
>+                startCollection();
>+            }
>+            position.setEmptyCollection(false);
>+            
>+            Level newLevel = new Level(false, position);
>+            position = newLevel;
>+            
>+            isLastEventStart = true;
>+        }else{
>+            Level rootLevel = new Level(false, null);
>+            position = rootLevel;
>+            if(rootJsonObjectBuilder == null){
>+                rootJsonObjectBuilder = Json.createObjectBuilder();
>+            }  
>+            
>+            rootLevel.setJsonObjectBuilder(rootJsonObjectBuilder);
>+        }
>+    }
>+
>+    @Override
>+    public void endDocument() {
>+        if(position != null){
>+            if(position.parentLevel != null && position.parentLevel.isCollection){
>+                popAndSetInParentBuilder();
>+            }else{
>+                //this is the root level list case
>+                position = position.parentLevel;
>+            }
>+        }
>+    }
>+    
>+    private void popAndSetInParentBuilder(){
>+        Level removedLevel = position;
>+        Level parentLevel = position.parentLevel;
>+        position = position.parentLevel;
>+        if(removedLevel.isCollection && removedLevel.isEmptyCollection() && removedLevel.keyName == null){
>+            return;
>+        }
>+      
>+        if(parentLevel != null){                  
>+            if(parentLevel.isCollection){
>+                if(removedLevel.isCollection){
>+                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonArrayBuilder());
>+                }else{                   
>+                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonObjectBuilder());
>+                }
>+            }else{
>+                if(removedLevel.isCollection){                    
>+                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonArrayBuilder());
>+                }else{
>+                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonObjectBuilder());
>+                }
>+            }
>+        }
>+        
>+    }    
>+    
>+    public void startCollection() {
>+        if(position == null){
>+             isRootArray = true;              
>+             Level rootLevel = new Level(true, null);
>+             if(rootJsonArrayBuilder == null){
>+                  rootJsonArrayBuilder = Json.createArrayBuilder();
>+             }
>+             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
>+             position = rootLevel;
>+        } else {            
>+            if(isLastEventStart){
>+                position.setComplex(true);           
>+            }            
>+            Level level = new Level(true, position);            
>+            position = level;
>+        }      
>+        isLastEventStart = false;
>+    }
>+    
>+    @Override
>+    public void endCollection() {
>+         popAndSetInParentBuilder();    
>+    }
>+    
>+    @Override    
>+    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
>+        super.openStartElement(xPathFragment, namespaceResolver);
>+        if(position != null){
>+            Level newLevel = new Level(false, position);            
>+            
>+            if(isLastEventStart){ 
>+                //this means 2 startevents in a row so the last this is a complex object
>+                position.setComplex(true);                                
>+            }
>+                      
>+            String keyName = getKeyName(xPathFragment);
>+           
>+            if(position.isCollection && position.isEmptyCollection() ){
>+                position.setKeyName(keyName);
>+            }else{
>+                newLevel.setKeyName(keyName);    
>+            }
>+            position = newLevel;   
>+            isLastEventStart = true;
>+        }
>+    }
>+    
>+    protected String getKeyName(XPathFragment xPathFragment){
>+        String keyName = xPathFragment.getLocalName(); 
>+       
>+        if(isNamespaceAware()){
>+            if(xPathFragment.getNamespaceURI() != null){
>+                String prefix = null;
>+                if(getNamespaceResolver() !=null){
>+                    prefix = getNamespaceResolver().resolveNamespaceURI(xPathFragment.getNamespaceURI());
>+                } else if(namespaceResolver != null){
>+                    prefix = namespaceResolver.resolveNamespaceURI(xPathFragment.getNamespaceURI());
>+                }
>+                if(prefix != null && !prefix.equals(Constants.EMPTY_STRING)){
>+                    keyName = prefix + getNamespaceSeparator() +  keyName;                           
>+                }
>+            }
>+        } 
>+        if(xPathFragment.isAttribute() && attributePrefix != null){
>+            keyName = attributePrefix + keyName;
>+        }
>+
>+        return keyName;
>+    }
>+
>+    public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver,  Object value, QName schemaType){
>+        if(xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI){
>+            return;
>+        }
>+        xPathFragment.setAttribute(true);
>+        openStartElement(xPathFragment, namespaceResolver);
>+        characters(schemaType, value, null, false, true);
>+        endElement(xPathFragment, namespaceResolver);
>+    }
>+    
>+    /**
>+     * INTERNAL:
>+     */
>+    @Override
>+    public void marshalWithoutRootElement(ObjectBuilder treeObjectBuilder, Object object, Descriptor descriptor, Root root, boolean isXMLRoot){
>+        if(treeObjectBuilder != null){
>+            addXsiTypeAndClassIndicatorIfRequired(descriptor, null, descriptor.getDefaultRootElementField(), root, object, isXMLRoot, true);
>+            treeObjectBuilder.marshalAttributes(this, object, session);
>+        }         
>+     }
>+    
>+    /**
>+     * INTERNAL:
>+     * The character used to separate the prefix and uri portions when namespaces are present 
>+     * @since 2.4
>+     */
>+    public char getNamespaceSeparator(){        
>+        return marshaller.getNamespaceSeparator();
>+    }
>+    
>+    /**
>+     * INTERNAL:
>+     * The optional fragment used to wrap the text() mappings
>+     * @since 2.4
>+     */
>+    public XPathFragment getTextWrapperFragment() {
>+        return textWrapperFragment;
>+    }
>+    
>+    @Override
>+    public boolean isWrapperAsCollectionName() {
>+        return marshaller.isWrapperAsCollectionName();
>+    }
>+    
>+    @Override
>+    public void element(XPathFragment frag) {
>+        isLastEventStart = false;
>+    }
>+    
>+    /**
>+     * Handle marshal of an empty collection.  
>+     * @param xPathFragment
>+     * @param namespaceResolver
>+     * @param openGrouping if grouping elements should be marshalled for empty collections
>+     * @return
>+     */    
>+    public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) {
>+
>+         if(marshaller.isMarshalEmptyCollections()){
>+             super.emptyCollection(xPathFragment, namespaceResolver, true);
>+             
>+             if (null != xPathFragment) {
>+                 
>+                 if(xPathFragment.isSelfFragment() || xPathFragment.nameIsText()){
>+                     String keyName = position.getKeyName();
>+                     position.setComplex(false);
>+                     position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());                     
>+                 }else{ 
>+                     if(isLastEventStart){
>+                         position.setComplex(true);                  
>+                     }                 
>+                     String keyName =  getKeyName(xPathFragment);
>+                     if(keyName != null){
>+                        position.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
>+                     }
>+                 }
>+                 isLastEventStart = false;   
>+             }
>+                  
>+             return true;
>+         }else{
>+             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
>+         }
>+    }
>+
>+    @Override
>+    public void attribute(XPathFragment xPathFragment,NamespaceResolver namespaceResolver, String value) {
>+        attribute(xPathFragment, namespaceResolver, value, null);
>+    }
>+
>+    @Override
>+    public void attribute(String namespaceURI, String localName, String qName, String value) {
>+        XPathFragment xPathFragment = new XPathFragment();
>+        xPathFragment.setNamespaceURI(namespaceURI);
>+        xPathFragment.setAttribute(true);
>+        xPathFragment.setLocalName(localName);
>+
>+        openStartElement(xPathFragment, namespaceResolver);
>+        characters(null, value, null, false, true);
>+
>+        endElement(xPathFragment, namespaceResolver);
>+        
>+    }
>+
>+    @Override
>+    public void closeStartElement() {}
>+
>+    @Override
>+    public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
>+        if(position != null){
>+            if(isLastEventStart){
>+                position.setComplex(true);
>+            }
>+            if(position.isComplex){
>+                popAndSetInParentBuilder();
>+            }else{
>+                position = position.parentLevel;
>+            }            
>+            isLastEventStart = false;          
>+        }
>+    }
>+
>+    @Override
>+    public void characters(String value) {
>+        writeValue(value, null, false);
>+    }
>+
>+    @Override
>+    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA){          
>+        characters(schemaType, value, mimeType, isCDATA, false);
>+     }
>+    
>+    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA, boolean isAttribute){
>+        if(mimeType != null) {
>+            if(value instanceof List){
>+               value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesListForBinaryValues((List)value, marshaller, mimeType);
>+           }else{
>+
>+            value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(value, marshaller, mimeType).getData();
>+           }
>+        }         
>+        if(schemaType != null && Constants.QNAME_QNAME.equals(schemaType)){
>+            String convertedValue = getStringForQName((QName)value);
>+            writeValue(convertedValue, null, isAttribute);
>+        } 
>+        else if(value.getClass() == String.class){          
>+            //if schemaType is set and it's a numeric or boolean type don't treat as a string
>+            if(schemaType != null && isNumericOrBooleanType(schemaType)){
>+                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);
>+                Object convertedValue = ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, theClass, schemaType);
>+                writeValue(convertedValue, schemaType, isAttribute);
>+            }else if(isCDATA){
>+                cdata((String)value);
>+            }else{
>+                writeValue((String)value, null, isAttribute);                
>+            }
>+       }else{
>+           Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>+
>+           if(schemaType == null || theClass == null){
>+               if(value.getClass() == CoreClassConstants.BOOLEAN || CoreClassConstants.NUMBER.isAssignableFrom(value.getClass())){
>+                   writeValue(value, schemaType, isAttribute);
>+               }else{
>+                   String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>+                   writeValue(convertedValue, schemaType, isAttribute);
>+               }
>+           }else if(schemaType != null && !isNumericOrBooleanType(schemaType)){
>+               //if schemaType exists and is not boolean or number do write quotes (convert to string)
>+               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>+               writeValue(convertedValue, schemaType, isAttribute);
>+           } else if(isCDATA){
>+               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>+               cdata(convertedValue);
>+           }else{
>+               writeValue(value, schemaType, isAttribute);           
>+           }
>+       }        
>+    }
>+    
>+    
>+    private boolean isNumericOrBooleanType(QName schemaType){
>+        if(schemaType == null){
>+            return false;
>+        }else if(schemaType.equals(Constants.BOOLEAN_QNAME)
>+                || schemaType.equals(Constants.INTEGER_QNAME)
>+                || schemaType.equals(Constants.INT_QNAME)
>+                || schemaType.equals(Constants.BYTE_QNAME)
>+                || schemaType.equals(Constants.DECIMAL_QNAME)
>+                || schemaType.equals(Constants.FLOAT_QNAME)
>+                || schemaType.equals(Constants.DOUBLE_QNAME)
>+                || schemaType.equals(Constants.SHORT_QNAME)
>+                || schemaType.equals(Constants.LONG_QNAME)
>+                || schemaType.equals(Constants.NEGATIVE_INTEGER_QNAME)
>+                || schemaType.equals(Constants.NON_NEGATIVE_INTEGER_QNAME)
>+                || schemaType.equals(Constants.NON_POSITIVE_INTEGER_QNAME)
>+                || schemaType.equals(Constants.POSITIVE_INTEGER_QNAME)
>+                || schemaType.equals(Constants.UNSIGNED_BYTE_QNAME)
>+                || schemaType.equals(Constants.UNSIGNED_INT_QNAME)
>+                || schemaType.equals(Constants.UNSIGNED_LONG_QNAME)
>+                || schemaType.equals(Constants.UNSIGNED_SHORT_QNAME)
>+        ){
>+            return true;
>+        }
>+        return false;
>+    }
>+    
>+    public void writeValue(Object value, QName schemaType, boolean isAttribute) {
>+        
>+        if (characterEscapeHandler != null && value instanceof String) {
>+            try {
>+                StringWriter stringWriter = new StringWriter();
>+                characterEscapeHandler.escape(((String)value).toCharArray(), 0, ((String)value).length(), isAttribute, stringWriter);
>+                value = stringWriter.toString();
>+            } catch (IOException e) {
>+                throw XMLMarshalException.marshalException(e);
>+            }
>+        }
>+        
>+        boolean textWrapperOpened = false;                       
>+        if(!isLastEventStart){
>+             openStartElement(textWrapperFragment, namespaceResolver);
>+             textWrapperOpened = true;
>+        }
>+      
>+        Level currentLevel = position;
>+        String keyName = position.getKeyName();
>+        if(!position.isComplex){           
>+            currentLevel = position.parentLevel;
>+            currentLevel.setComplex(true);          
>+        }
>+        if(currentLevel.isCollection()){
>+            currentLevel.setEmptyCollection(false);
>+            addValueToArrayBuilder(currentLevel.getJsonArrayBuilder(), value, schemaType);            
>+        } else {
>+            JsonObjectBuilder builder = currentLevel.getJsonObjectBuilder();                   
>+            addValueToObjectBuilder(builder, keyName, value, schemaType);          
>+        }
>+        isLastEventStart = false;
>+        if(textWrapperOpened){    
>+             endElement(textWrapperFragment, namespaceResolver);
>+        }    
>+    }
>+    
>+    private void addValueToObjectBuilder(JsonObjectBuilder jsonObjectBuilder, String keyName, Object value, QName schemaType){
>+        if(value == NULL){
>+            jsonObjectBuilder.addNull(keyName);
>+        }else if(value instanceof Integer){
>+            jsonObjectBuilder.add(keyName, (Integer)value);  
>+        }else if(value instanceof BigDecimal){
>+            jsonObjectBuilder.add(keyName, (BigDecimal)value);   
>+        }else if(value instanceof BigInteger){
>+            jsonObjectBuilder.add(keyName, (BigInteger)value);               
>+        }else if(value instanceof Boolean){
>+            jsonObjectBuilder.add(keyName, (Boolean)value);
>+        }else if(value instanceof Character){
>+            jsonObjectBuilder.add(keyName, (Character)value);  
>+        }else if(value instanceof Double){
>+            jsonObjectBuilder.add(keyName, (Double)value);
>+        }else if(value instanceof Float){
>+            jsonObjectBuilder.add(keyName, (Float)value);
>+        }else if(value instanceof Long){
>+            jsonObjectBuilder.add(keyName, (Long)value);
>+        }else if(value instanceof String){
>+            jsonObjectBuilder.add(keyName, (String)value);                
>+        }else{
>+            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>+            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>+            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
>+                //if it's still a number and falls through the cracks we dont want "" around the value
>+                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
>+                    jsonObjectBuilder.add(keyName, (BigDecimal)convertedNumberValue);
>+            }else{
>+                jsonObjectBuilder.add(keyName, convertedValue);
>+            }
>+                
>+        }
>+    }
>+    
>+    private void addValueToArrayBuilder(JsonArrayBuilder jsonArrayBuilder, Object value, QName schemaType){
>+        if(value == NULL){
>+            jsonArrayBuilder.addNull();
>+        }else if(value instanceof Integer){
>+            jsonArrayBuilder.add((Integer)value);  
>+        }else if(value instanceof BigDecimal){
>+            jsonArrayBuilder.add((BigDecimal)value);   
>+        }else if(value instanceof BigInteger){
>+            jsonArrayBuilder.add((BigInteger)value);               
>+        }else if(value instanceof Boolean){                
>+            jsonArrayBuilder.add((Boolean)value);
>+        }else if(value instanceof Character){
>+            jsonArrayBuilder.add((Character)value);  
>+        }else if(value instanceof Double){
>+            jsonArrayBuilder.add((Double)value);
>+        }else if(value instanceof Float){
>+            jsonArrayBuilder.add((Float)value);
>+        }else if(value instanceof Long){
>+            jsonArrayBuilder.add((Long)value);
>+        }else if(value instanceof String){
>+            jsonArrayBuilder.add((String)value);
>+        }else{
>+            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>+            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>+            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
>+                //if it's still a number and falls through the cracks we dont want "" around the value
>+                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
>+                    jsonArrayBuilder.add((BigDecimal)convertedNumberValue);
>+            }else{
>+                jsonArrayBuilder.add(convertedValue);
>+            }
>+        }
>+    }
>+    
>+    @Override
>+    public void cdata(String value) {
>+        characters(value);        
>+    }
>+
>+    @Override
>+    public void node(Node node, NamespaceResolver resolver, String uri, String name) {
>+       
>+        if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
>+            Attr attr = (Attr) node;
>+            String resolverPfx = null;
>+            if (getNamespaceResolver() != null) {
>+                resolverPfx = this.getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI());
>+            }
>+            String namespaceURI = attr.getNamespaceURI();
>+            // If the namespace resolver contains a prefix for the attribute's URI,
>+            // use it instead of what is set on the attribute
>+            if (resolverPfx != null) {
>+                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, resolverPfx+Constants.COLON+attr.getLocalName(), attr.getNodeValue());
>+            } else {
>+                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, attr.getName(), attr.getNodeValue());
>+                // May need to declare the URI locally
>+                if (attr.getNamespaceURI() != null) {
>+                    attribute(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, Constants.EMPTY_STRING, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON + attr.getPrefix(), attr.getNamespaceURI());
>+                    this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI());
>+                }
>+            }
>+        } else if (node.getNodeType() == Node.TEXT_NODE) {
>+            writeValue(node.getNodeValue(), null, false);
>+        } else {
>+            try {
>+                JsonBuilderRecordContentHandler wrcHandler = new JsonBuilderRecordContentHandler();
>+                
>+                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 JsonBuilderRecordContentHandler implements ExtendedContentHandler, LexicalHandler {
>+
>+         JsonBuilderRecordContentHandler() {
>+         }
>+
>+         // --------------------- 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);
>+             
>+             JsonBuilderRecord.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 {           
>+             JsonBuilderRecord.this.characters(characters.toString());      
>+         }
>+
>+         // --------------------- LEXICALHANDLER METHODS --------------------- //
>+         public void comment(char[] ch, int start, int length) throws SAXException {
>+         }
>+
>+         public void startCDATA() throws SAXException {
>+         }
>+
>+         public void endCDATA() throws SAXException {
>+         }
>+
>+         // --------------------- CONVENIENCE METHODS --------------------- //
>+            protected void handleAttributes(Attributes atts) {
>+             for (int i=0, attsLength = atts.getLength(); i<attsLength; i++) {
>+                 String qName = atts.getQName(i);
>+                 if((qName != null && (qName.startsWith(javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON) || qName.equals(javax.xml.XMLConstants.XMLNS_ATTRIBUTE)))) {
>+                     continue;
>+                 }
>+                 attribute(atts.getURI(i), atts.getLocalName(i), qName, atts.getValue(i));
>+             }
>+         }
>+
>+         protected void writeComment(char[] chars, int start, int length) {        
>+         }
>+        
>+         protected void writeCharacters(char[] chars, int start, int length) {
>+             try {
>+                 characters(chars, start, length);
>+             } catch (SAXException e) {
>+                 throw XMLMarshalException.marshalException(e);
>+             }           
>+         }
>+         // --------------- SATISFY CONTENTHANDLER INTERFACE --------------- //
>+         public void endPrefixMapping(String prefix) throws SAXException {}
>+         public void processingInstruction(String target, String data) throws SAXException {}
>+         public void setDocumentLocator(Locator locator) {}
>+         public void startDocument() throws SAXException {}
>+         public void endDocument() throws SAXException {}
>+         public void skippedEntity(String name) throws SAXException {}
>+         public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {}
>+
>+         // --------------- SATISFY LEXICALHANDLER INTERFACE --------------- //
>+         public void startEntity(String name) throws SAXException {}
>+         public void endEntity(String name) throws SAXException {}
>+         public void startDTD(String name, String publicId, String systemId) throws SAXException {}
>+         public void endDTD() throws SAXException {}
>+         @Override
>+         public void setNil(boolean isNil) {}
>+
>+     }
>+
>+     
>+     /**
>+     * Instances of this class are used to maintain state about the current
>+     * level of the JSON message being marshalled.
>+     */
>+    protected static class Level {
>+        
>+        private boolean isCollection;
>+        private boolean emptyCollection;
>+        private String keyName;        
>+        private JsonObjectBuilder jsonObjectBuilder;
>+        private JsonArrayBuilder jsonArrayBuilder;
>+        private boolean isComplex;
>+        private Level parentLevel;
>+        
>+        public Level(boolean isCollection, Level parentLevel) {
>+            setCollection(isCollection);
>+            emptyCollection = true;
>+            this.parentLevel = parentLevel;
>+        }
>+
>+        public boolean isCollection() {
>+            return isCollection;
>+        }
>+
>+        public void setCollection(boolean isCollection) {
>+            this.isCollection = isCollection;
>+            if(isCollection && jsonArrayBuilder == null){
>+                jsonArrayBuilder = Json.createArrayBuilder();
>+            }
>+        }
>+
>+        public String getKeyName() {
>+            return keyName;
>+        }
>+
>+        public void setKeyName(String keyName) {
>+            this.keyName = keyName;
>+        }
>+
>+        public JsonObjectBuilder getJsonObjectBuilder() {
>+            return jsonObjectBuilder;
>+        }
>+
>+        public void setJsonObjectBuilder(JsonObjectBuilder jsonObjectBuilder) {
>+            this.jsonObjectBuilder = jsonObjectBuilder;
>+        }
>+
>+        public JsonArrayBuilder getJsonArrayBuilder() {
>+            return jsonArrayBuilder;
>+        }
>+
>+        public void setJsonArrayBuilder(JsonArrayBuilder jsonArrayBuilder) {
>+            this.jsonArrayBuilder = jsonArrayBuilder;
>+        }
>+
>+        public boolean isEmptyCollection() {
>+            return emptyCollection;
>+        }
>+
>+        public void setEmptyCollection(boolean emptyCollection) {
>+            this.emptyCollection = emptyCollection;
>+        }
>+        public boolean isComplex() {
>+            return isComplex;
>+        }
>+
>+        public void setComplex(boolean isComplex) {
>+            this.isComplex = isComplex;
>+            if(isComplex && jsonObjectBuilder == null){
>+                jsonObjectBuilder = Json.createObjectBuilder();
>+            }
>+        }
>+
>+    }
>+
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderWriterRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderWriterRecord.java
>deleted file mode 100644
>index 288a86d..0000000
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderWriterRecord.java
>+++ /dev/null
>@@ -1,813 +0,0 @@
>-/*******************************************************************************
>- * 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.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;
>-
>-public class JsonBuilderWriterRecord 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 JsonBuilderWriterRecord(){
>-        super();
>-        isLastEventStart = false;
>-    }
>-    
>-    public JsonBuilderWriterRecord(JsonObjectBuilder jsonObjectBuilder){
>-        this();
>-        rootJsonObjectBuilder = jsonObjectBuilder;
>-    }
>-    
>-    public JsonBuilderWriterRecord(JsonArrayBuilder jsonArrayBuilder){
>-        this();
>-        rootJsonArrayBuilder = jsonArrayBuilder;
>-        isRootArray = true;
>-    }
>-    
>-    /**
>-     * 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){
>-            if(position == null){
>-                startCollection();
>-            }
>-            position.setEmptyCollection(false);
>-            
>-            Level newLevel = new Level(false, position);
>-            position = newLevel;
>-            
>-            isLastEventStart = true;
>-        }else{
>-            Level rootLevel = new Level(false, null);
>-            position = rootLevel;
>-            if(rootJsonObjectBuilder == null){
>-                rootJsonObjectBuilder = Json.createObjectBuilder();
>-            }  
>-            
>-            rootLevel.setJsonObjectBuilder(rootJsonObjectBuilder);
>-        }
>-    }
>-
>-    @Override
>-    public void endDocument() {
>-        if(position != null){
>-            if(position.parentLevel != null && position.parentLevel.isCollection){
>-                popAndSetInParentBuilder();
>-            }else{
>-                //this is the root level list case
>-                position = position.parentLevel;
>-            }
>-        }
>-    }
>-    
>-    private void popAndSetInParentBuilder(){
>-        Level removedLevel = position;
>-        Level parentLevel = position.parentLevel;
>-        position = position.parentLevel;
>-        if(removedLevel.isCollection && removedLevel.isEmptyCollection() && removedLevel.keyName == null){
>-            return;
>-        }
>-      
>-        if(parentLevel != null){                  
>-            if(parentLevel.isCollection){
>-                if(removedLevel.isCollection){
>-                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonArrayBuilder());
>-                }else{                   
>-                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonObjectBuilder());
>-                }
>-            }else{
>-                if(removedLevel.isCollection){                    
>-                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonArrayBuilder());
>-                }else{
>-                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonObjectBuilder());
>-                }
>-            }
>-        }
>-        
>-    }    
>-    
>-    public void startCollection() {
>-        if(position == null){
>-             isRootArray = true;              
>-             Level rootLevel = new Level(true, null);
>-             if(rootJsonArrayBuilder == null){
>-                  rootJsonArrayBuilder = Json.createArrayBuilder();
>-             }
>-             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
>-             position = rootLevel;
>-        } else {            
>-            if(isLastEventStart){
>-                position.setComplex(true);           
>-            }            
>-            Level level = new Level(true, position);            
>-            position = level;
>-        }      
>-        isLastEventStart = false;
>-    }
>-    
>-    @Override
>-    public void endCollection() {
>-         popAndSetInParentBuilder();    
>-    }
>-    
>-    @Override    
>-    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
>-        super.openStartElement(xPathFragment, namespaceResolver);
>-        if(position != null){
>-            Level newLevel = new Level(false, position);            
>-            
>-            if(isLastEventStart){ 
>-                //this means 2 startevents in a row so the last this is a complex object
>-                position.setComplex(true);                                
>-            }
>-                      
>-            String keyName = getKeyName(xPathFragment);
>-           
>-            if(position.isCollection && position.isEmptyCollection() ){
>-                position.setKeyName(keyName);
>-            }else{
>-                newLevel.setKeyName(keyName);    
>-            }
>-            position = newLevel;   
>-            isLastEventStart = true;
>-        }
>-    }
>-    
>-    protected String getKeyName(XPathFragment xPathFragment){
>-        String keyName = xPathFragment.getLocalName(); 
>-       
>-        if(isNamespaceAware()){
>-            if(xPathFragment.getNamespaceURI() != null){
>-                String prefix = null;
>-                if(getNamespaceResolver() !=null){
>-                    prefix = getNamespaceResolver().resolveNamespaceURI(xPathFragment.getNamespaceURI());
>-                } else if(namespaceResolver != null){
>-                    prefix = namespaceResolver.resolveNamespaceURI(xPathFragment.getNamespaceURI());
>-                }
>-                if(prefix != null && !prefix.equals(Constants.EMPTY_STRING)){
>-                    keyName = prefix + getNamespaceSeparator() +  keyName;                           
>-                }
>-            }
>-        } 
>-        if(xPathFragment.isAttribute() && attributePrefix != null){
>-            keyName = attributePrefix + keyName;
>-        }
>-
>-        return keyName;
>-    }
>-
>-    public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver,  Object value, QName schemaType){
>-        if(xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI){
>-            return;
>-        }
>-        xPathFragment.setAttribute(true);
>-        openStartElement(xPathFragment, namespaceResolver);
>-        characters(schemaType, value, null, false, true);
>-        endElement(xPathFragment, namespaceResolver);
>-    }
>-    
>-    /**
>-     * INTERNAL:
>-     */
>-    @Override
>-    public void marshalWithoutRootElement(ObjectBuilder treeObjectBuilder, Object object, Descriptor descriptor, Root root, boolean isXMLRoot){
>-        if(treeObjectBuilder != null){
>-            addXsiTypeAndClassIndicatorIfRequired(descriptor, null, descriptor.getDefaultRootElementField(), root, object, isXMLRoot, true);
>-            treeObjectBuilder.marshalAttributes(this, object, session);
>-        }         
>-     }
>-    
>-    /**
>-     * INTERNAL:
>-     * The character used to separate the prefix and uri portions when namespaces are present 
>-     * @since 2.4
>-     */
>-    public char getNamespaceSeparator(){        
>-        return marshaller.getNamespaceSeparator();
>-    }
>-    
>-    /**
>-     * INTERNAL:
>-     * The optional fragment used to wrap the text() mappings
>-     * @since 2.4
>-     */
>-    public XPathFragment getTextWrapperFragment() {
>-        return textWrapperFragment;
>-    }
>-    
>-    @Override
>-    public boolean isWrapperAsCollectionName() {
>-        return marshaller.isWrapperAsCollectionName();
>-    }
>-    
>-    @Override
>-    public void element(XPathFragment frag) {
>-        isLastEventStart = false;
>-    }
>-    
>-    /**
>-     * Handle marshal of an empty collection.  
>-     * @param xPathFragment
>-     * @param namespaceResolver
>-     * @param openGrouping if grouping elements should be marshalled for empty collections
>-     * @return
>-     */    
>-    public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) {
>-
>-         if(marshaller.isMarshalEmptyCollections()){
>-             super.emptyCollection(xPathFragment, namespaceResolver, true);
>-             
>-             if (null != xPathFragment) {
>-                 
>-                 if(xPathFragment.isSelfFragment() || xPathFragment.nameIsText()){
>-                     String keyName = position.getKeyName();
>-                     position.setComplex(false);
>-                     position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());                     
>-                 }else{ 
>-                     if(isLastEventStart){
>-                         position.setComplex(true);                  
>-                     }                 
>-                     String keyName =  getKeyName(xPathFragment);
>-                     if(keyName != null){
>-                        position.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
>-                     }
>-                 }
>-                 isLastEventStart = false;   
>-             }
>-                  
>-             return true;
>-         }else{
>-             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
>-         }
>-    }
>-
>-    @Override
>-    public void attribute(XPathFragment xPathFragment,NamespaceResolver namespaceResolver, String value) {
>-        attribute(xPathFragment, namespaceResolver, value, null);
>-    }
>-
>-    @Override
>-    public void attribute(String namespaceURI, String localName, String qName, String value) {
>-        XPathFragment xPathFragment = new XPathFragment();
>-        xPathFragment.setNamespaceURI(namespaceURI);
>-        xPathFragment.setAttribute(true);
>-        xPathFragment.setLocalName(localName);
>-
>-        openStartElement(xPathFragment, namespaceResolver);
>-        characters(null, value, null, false, true);
>-
>-        endElement(xPathFragment, namespaceResolver);
>-        
>-    }
>-
>-    @Override
>-    public void closeStartElement() {}
>-
>-    @Override
>-    public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
>-        if(position != null){
>-            if(isLastEventStart){
>-                position.setComplex(true);
>-            }
>-            if(position.isComplex){
>-                popAndSetInParentBuilder();
>-            }else{
>-                position = position.parentLevel;
>-            }            
>-            isLastEventStart = false;          
>-        }
>-    }
>-
>-    @Override
>-    public void characters(String value) {
>-        writeValue(value, null, false);
>-    }
>-
>-    @Override
>-    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA){          
>-        characters(schemaType, value, mimeType, isCDATA, false);
>-     }
>-    
>-    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA, boolean isAttribute){
>-        if(mimeType != null) {
>-            if(value instanceof List){
>-               value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesListForBinaryValues((List)value, marshaller, mimeType);
>-           }else{
>-
>-            value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(value, marshaller, mimeType).getData();
>-           }
>-        }         
>-        if(schemaType != null && Constants.QNAME_QNAME.equals(schemaType)){
>-            String convertedValue = getStringForQName((QName)value);
>-            writeValue(convertedValue, null, isAttribute);
>-        } 
>-        else if(value.getClass() == String.class){          
>-            //if schemaType is set and it's a numeric or boolean type don't treat as a string
>-            if(schemaType != null && isNumericOrBooleanType(schemaType)){
>-                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);
>-                Object convertedValue = ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, theClass, schemaType);
>-                writeValue(convertedValue, schemaType, isAttribute);
>-            }else if(isCDATA){
>-                cdata((String)value);
>-            }else{
>-                writeValue((String)value, null, isAttribute);                
>-            }
>-       }else{
>-           Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>-
>-           if(schemaType == null || theClass == null){
>-               if(value.getClass() == CoreClassConstants.BOOLEAN || CoreClassConstants.NUMBER.isAssignableFrom(value.getClass())){
>-                   writeValue(value, schemaType, isAttribute);
>-               }else{
>-                   String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>-                   writeValue(convertedValue, schemaType, isAttribute);
>-               }
>-           }else if(schemaType != null && !isNumericOrBooleanType(schemaType)){
>-               //if schemaType exists and is not boolean or number do write quotes (convert to string)
>-               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>-               writeValue(convertedValue, schemaType, isAttribute);
>-           } else if(isCDATA){
>-               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>-               cdata(convertedValue);
>-           }else{
>-               writeValue(value, schemaType, isAttribute);           
>-           }
>-       }        
>-    }
>-    
>-    
>-    private boolean isNumericOrBooleanType(QName schemaType){
>-        if(schemaType == null){
>-            return false;
>-        }else if(schemaType.equals(Constants.BOOLEAN_QNAME)
>-                || schemaType.equals(Constants.INTEGER_QNAME)
>-                || schemaType.equals(Constants.INT_QNAME)
>-                || schemaType.equals(Constants.BYTE_QNAME)
>-                || schemaType.equals(Constants.DECIMAL_QNAME)
>-                || schemaType.equals(Constants.FLOAT_QNAME)
>-                || schemaType.equals(Constants.DOUBLE_QNAME)
>-                || schemaType.equals(Constants.SHORT_QNAME)
>-                || schemaType.equals(Constants.LONG_QNAME)
>-                || schemaType.equals(Constants.NEGATIVE_INTEGER_QNAME)
>-                || schemaType.equals(Constants.NON_NEGATIVE_INTEGER_QNAME)
>-                || schemaType.equals(Constants.NON_POSITIVE_INTEGER_QNAME)
>-                || schemaType.equals(Constants.POSITIVE_INTEGER_QNAME)
>-                || schemaType.equals(Constants.UNSIGNED_BYTE_QNAME)
>-                || schemaType.equals(Constants.UNSIGNED_INT_QNAME)
>-                || schemaType.equals(Constants.UNSIGNED_LONG_QNAME)
>-                || schemaType.equals(Constants.UNSIGNED_SHORT_QNAME)
>-        ){
>-            return true;
>-        }
>-        return false;
>-    }
>-    
>-    public void writeValue(Object value, QName schemaType, boolean isAttribute) {
>-        
>-        if (characterEscapeHandler != null && value instanceof String) {
>-            try {
>-                StringWriter stringWriter = new StringWriter();
>-                characterEscapeHandler.escape(((String)value).toCharArray(), 0, ((String)value).length(), isAttribute, stringWriter);
>-                value = stringWriter.toString();
>-            } catch (IOException e) {
>-                throw XMLMarshalException.marshalException(e);
>-            }
>-        }
>-        
>-        boolean textWrapperOpened = false;                       
>-        if(!isLastEventStart){
>-             openStartElement(textWrapperFragment, namespaceResolver);
>-             textWrapperOpened = true;
>-        }
>-      
>-        Level currentLevel = position;
>-        String keyName = position.getKeyName();
>-        if(!position.isComplex){           
>-            currentLevel = position.parentLevel;
>-            currentLevel.setComplex(true);          
>-        }
>-        if(currentLevel.isCollection()){
>-            currentLevel.setEmptyCollection(false);
>-            addValueToArrayBuilder(currentLevel.getJsonArrayBuilder(), value, schemaType);            
>-        } else {
>-            JsonObjectBuilder builder = currentLevel.getJsonObjectBuilder();                   
>-            addValueToObjectBuilder(builder, keyName, value, schemaType);          
>-        }
>-        isLastEventStart = false;
>-        if(textWrapperOpened){    
>-             endElement(textWrapperFragment, namespaceResolver);
>-        }    
>-    }
>-    
>-    private void addValueToObjectBuilder(JsonObjectBuilder jsonObjectBuilder, String keyName, Object value, QName schemaType){
>-        if(value == NULL){
>-            jsonObjectBuilder.addNull(keyName);
>-        }else if(value instanceof Integer){
>-            jsonObjectBuilder.add(keyName, (Integer)value);  
>-        }else if(value instanceof BigDecimal){
>-            jsonObjectBuilder.add(keyName, (BigDecimal)value);   
>-        }else if(value instanceof BigInteger){
>-            jsonObjectBuilder.add(keyName, (BigInteger)value);               
>-        }else if(value instanceof Boolean){
>-            jsonObjectBuilder.add(keyName, (Boolean)value);
>-        }else if(value instanceof Character){
>-            jsonObjectBuilder.add(keyName, (Character)value);  
>-        }else if(value instanceof Double){
>-            jsonObjectBuilder.add(keyName, (Double)value);
>-        }else if(value instanceof Float){
>-            jsonObjectBuilder.add(keyName, (Float)value);
>-        }else if(value instanceof Long){
>-            jsonObjectBuilder.add(keyName, (Long)value);
>-        }else if(value instanceof String){
>-            jsonObjectBuilder.add(keyName, (String)value);                
>-        }else{
>-            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>-            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>-            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
>-                //if it's still a number and falls through the cracks we dont want "" around the value
>-                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
>-                    jsonObjectBuilder.add(keyName, (BigDecimal)convertedNumberValue);
>-            }else{
>-                jsonObjectBuilder.add(keyName, convertedValue);
>-            }
>-                
>-        }
>-    }
>-    
>-    private void addValueToArrayBuilder(JsonArrayBuilder jsonArrayBuilder, Object value, QName schemaType){
>-        if(value == NULL){
>-            jsonArrayBuilder.addNull();
>-        }else if(value instanceof Integer){
>-            jsonArrayBuilder.add((Integer)value);  
>-        }else if(value instanceof BigDecimal){
>-            jsonArrayBuilder.add((BigDecimal)value);   
>-        }else if(value instanceof BigInteger){
>-            jsonArrayBuilder.add((BigInteger)value);               
>-        }else if(value instanceof Boolean){                
>-            jsonArrayBuilder.add((Boolean)value);
>-        }else if(value instanceof Character){
>-            jsonArrayBuilder.add((Character)value);  
>-        }else if(value instanceof Double){
>-            jsonArrayBuilder.add((Double)value);
>-        }else if(value instanceof Float){
>-            jsonArrayBuilder.add((Float)value);
>-        }else if(value instanceof Long){
>-            jsonArrayBuilder.add((Long)value);
>-        }else if(value instanceof String){
>-            jsonArrayBuilder.add((String)value);
>-        }else{
>-            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
>-            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
>-            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
>-                //if it's still a number and falls through the cracks we dont want "" around the value
>-                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
>-                    jsonArrayBuilder.add((BigDecimal)convertedNumberValue);
>-            }else{
>-                jsonArrayBuilder.add(convertedValue);
>-            }
>-        }
>-    }
>-    
>-    @Override
>-    public void cdata(String value) {
>-        characters(value);        
>-    }
>-
>-    @Override
>-    public void node(Node node, NamespaceResolver resolver, String uri, String name) {
>-       
>-        if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
>-            Attr attr = (Attr) node;
>-            String resolverPfx = null;
>-            if (getNamespaceResolver() != null) {
>-                resolverPfx = this.getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI());
>-            }
>-            String namespaceURI = attr.getNamespaceURI();
>-            // If the namespace resolver contains a prefix for the attribute's URI,
>-            // use it instead of what is set on the attribute
>-            if (resolverPfx != null) {
>-                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, resolverPfx+Constants.COLON+attr.getLocalName(), attr.getNodeValue());
>-            } else {
>-                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, attr.getName(), attr.getNodeValue());
>-                // May need to declare the URI locally
>-                if (attr.getNamespaceURI() != null) {
>-                    attribute(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, Constants.EMPTY_STRING, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON + attr.getPrefix(), attr.getNamespaceURI());
>-                    this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI());
>-                }
>-            }
>-        } else if (node.getNodeType() == Node.TEXT_NODE) {
>-            writeValue(node.getNodeValue(), null, false);
>-        } else {
>-            try {
>-                JsonBuilderRecordContentHandler wrcHandler = new JsonBuilderRecordContentHandler();
>-                
>-                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 JsonBuilderRecordContentHandler implements ExtendedContentHandler, LexicalHandler {
>-
>-         JsonBuilderRecordContentHandler() {
>-         }
>-
>-         // --------------------- 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);
>-             
>-             JsonBuilderWriterRecord.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 {           
>-             JsonBuilderWriterRecord.this.characters(characters.toString());      
>-         }
>-
>-         // --------------------- LEXICALHANDLER METHODS --------------------- //
>-         public void comment(char[] ch, int start, int length) throws SAXException {
>-         }
>-
>-         public void startCDATA() throws SAXException {
>-         }
>-
>-         public void endCDATA() throws SAXException {
>-         }
>-
>-         // --------------------- CONVENIENCE METHODS --------------------- //
>-            protected void handleAttributes(Attributes atts) {
>-             for (int i=0, attsLength = atts.getLength(); i<attsLength; i++) {
>-                 String qName = atts.getQName(i);
>-                 if((qName != null && (qName.startsWith(javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON) || qName.equals(javax.xml.XMLConstants.XMLNS_ATTRIBUTE)))) {
>-                     continue;
>-                 }
>-                 attribute(atts.getURI(i), atts.getLocalName(i), qName, atts.getValue(i));
>-             }
>-         }
>-
>-         protected void writeComment(char[] chars, int start, int length) {        
>-         }
>-        
>-         protected void writeCharacters(char[] chars, int start, int length) {
>-             try {
>-                 characters(chars, start, length);
>-             } catch (SAXException e) {
>-                 throw XMLMarshalException.marshalException(e);
>-             }           
>-         }
>-         // --------------- SATISFY CONTENTHANDLER INTERFACE --------------- //
>-         public void endPrefixMapping(String prefix) throws SAXException {}
>-         public void processingInstruction(String target, String data) throws SAXException {}
>-         public void setDocumentLocator(Locator locator) {}
>-         public void startDocument() throws SAXException {}
>-         public void endDocument() throws SAXException {}
>-         public void skippedEntity(String name) throws SAXException {}
>-         public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {}
>-
>-         // --------------- SATISFY LEXICALHANDLER INTERFACE --------------- //
>-         public void startEntity(String name) throws SAXException {}
>-         public void endEntity(String name) throws SAXException {}
>-         public void startDTD(String name, String publicId, String systemId) throws SAXException {}
>-         public void endDTD() throws SAXException {}
>-         @Override
>-         public void setNil(boolean isNil) {}
>-
>-     }
>-
>-     
>-     /**
>-     * Instances of this class are used to maintain state about the current
>-     * level of the JSON message being marshalled.
>-     */
>-    protected static class Level {
>-        
>-        private boolean isCollection;
>-        private boolean emptyCollection;
>-        private String keyName;        
>-        private JsonObjectBuilder jsonObjectBuilder;
>-        private JsonArrayBuilder jsonArrayBuilder;
>-        private boolean isComplex;
>-        private Level parentLevel;
>-        
>-        public Level(boolean isCollection, Level parentLevel) {
>-            setCollection(isCollection);
>-            emptyCollection = true;
>-            this.parentLevel = parentLevel;
>-        }
>-
>-        public boolean isCollection() {
>-            return isCollection;
>-        }
>-
>-        public void setCollection(boolean isCollection) {
>-            this.isCollection = isCollection;
>-            if(isCollection && jsonArrayBuilder == null){
>-                jsonArrayBuilder = Json.createArrayBuilder();
>-            }
>-        }
>-
>-        public String getKeyName() {
>-            return keyName;
>-        }
>-
>-        public void setKeyName(String keyName) {
>-            this.keyName = keyName;
>-        }
>-
>-        public JsonObjectBuilder getJsonObjectBuilder() {
>-            return jsonObjectBuilder;
>-        }
>-
>-        public void setJsonObjectBuilder(JsonObjectBuilder jsonObjectBuilder) {
>-            this.jsonObjectBuilder = jsonObjectBuilder;
>-        }
>-
>-        public JsonArrayBuilder getJsonArrayBuilder() {
>-            return jsonArrayBuilder;
>-        }
>-
>-        public void setJsonArrayBuilder(JsonArrayBuilder jsonArrayBuilder) {
>-            this.jsonArrayBuilder = jsonArrayBuilder;
>-        }
>-
>-        public boolean isEmptyCollection() {
>-            return emptyCollection;
>-        }
>-
>-        public void setEmptyCollection(boolean emptyCollection) {
>-            this.emptyCollection = emptyCollection;
>-        }
>-        public boolean isComplex() {
>-            return isComplex;
>-        }
>-
>-        public void setComplex(boolean isComplex) {
>-            this.isComplex = isComplex;
>-            if(isComplex && jsonObjectBuilder == null){
>-                jsonObjectBuilder = Json.createObjectBuilder();
>-            }
>-        }
>-
>-    }
>-
>-}
>

Actions: View | Diff

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