Attachment 233848 Details for Bug 411382 – Cleanup update

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

[patch] Cleanup update

bug411382_trunk_update2.patch (text/plain), 32.22 KB, created by Denise Smith

on 2013-07-26 13:28:17 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Denise Smith

Created: 2013-07-26 13:28:17 EDT

Size: 32.22 KB

patch

obsolete

> .../persistence/oxm/record/JsonBuilderRecord.java  | 247 ++++-----------------
> .../oxm/record/JsonGeneratorRecord.java            | 204 +++--------------
> .../eclipse/persistence/oxm/record/JsonRecord.java | 188 +++++++++++++++-
> 7 files changed, 266 insertions(+), 382 deletions(-)
>
>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
>index dcbf116..624ecc5 100644
>--- 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
>@@ -12,8 +12,6 @@
>  ******************************************************************************/
> package org.eclipse.persistence.oxm.record;
> 
>-import java.io.IOException;
>-import java.io.StringWriter;
> import java.math.BigDecimal;
> import java.math.BigInteger;
> 
>@@ -22,21 +20,15 @@ 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.oxm.ConversionManager;
>-import org.eclipse.persistence.internal.oxm.NamespaceResolver;
>-import org.eclipse.persistence.internal.oxm.XPathFragment;
> import org.eclipse.persistence.internal.oxm.XMLConversionManager;
>-import org.eclipse.persistence.oxm.record.JsonRecord.Level;
> 
>-public class JsonBuilderRecord extends JsonRecord {
>-
>-    private Level position;
>+public class JsonBuilderRecord extends JsonRecord<JsonBuilderRecord.Level> {
>+ 
>     private JsonObjectBuilder rootJsonObjectBuilder;
>     private JsonArrayBuilder rootJsonArrayBuilder;
>  
>-    
>     public JsonBuilderRecord(){
>         super();
>         isLastEventStart = false;
>@@ -52,217 +44,69 @@ public class JsonBuilderRecord extends JsonRecord {
>         rootJsonArrayBuilder = jsonArrayBuilder;
>         isRootArray = true;
>     }
>-      
>-    @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);
>-        }
>+     
>+    protected Level createNewLevel(boolean collection, Level parentLevel){
>+      return new Level(collection, position);       
>     }
>-
>-    @Override
>-    public void endDocument() {
>-        if(position != null){
>-            if(position.parentLevel != null && position.parentLevel.isCollection){
>-                popAndSetInParentBuilder();
>-            }else{
>-                //this is the root level list case
>-                position = (Level) position.parentLevel;
>-            }
>-        }
>+  
>+    protected void startRootObject(){
>+        super.startRootObject();                
>+        position.setJsonObjectBuilder(rootJsonObjectBuilder);
>+        setComplex(position, true);
>     }
>+       
>+    protected void finishLevel(){
>+        if(!(position.isCollection && position.isEmptyCollection() && position.getKeyName() == null)){
>+            
>+            Level parentLevel = (Level) position.parentLevel;
>     
>-    private void popAndSetInParentBuilder(){
>-        Level removedLevel = position;
>-        Level parentLevel = (Level) position.parentLevel;
>-        position = (Level) 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());
>+            if(parentLevel != null){                  
>+                if(parentLevel.isCollection){
>+                    if(position.isCollection){
>+                        parentLevel.getJsonArrayBuilder().add(position.getJsonArrayBuilder());
>+                    }else{                   
>+                        parentLevel.getJsonArrayBuilder().add(position.getJsonObjectBuilder());
>+                    }
>                 }else{
>-                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonObjectBuilder());
>+                    if(position.isCollection){                    
>+                        parentLevel.getJsonObjectBuilder().add(position.getKeyName(), position.getJsonArrayBuilder());
>+                    }else{
>+                        parentLevel.getJsonObjectBuilder().add(position.getKeyName(), position.getJsonObjectBuilder());
>+                    }
>                 }
>             }
>         }
>-        
>+        super.finishLevel();      
>     }    
>     
>-    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){
>-                setComplex(position, true);           
>-            }            
>-            Level level = new Level(true, position);            
>-            position = level;
>-        }      
>-        isLastEventStart = false;
>+    protected void startRootLevelCollection(){
>+        if(rootJsonArrayBuilder == null){
>+            rootJsonArrayBuilder = Json.createArrayBuilder();
>+       }
>+       position.setJsonArrayBuilder(rootJsonArrayBuilder); 
>     }
>-    
>+
>     @Override
>     public void endCollection() {
>-         popAndSetInParentBuilder();    
>+        finishLevel();    
>     }
>     
>-    private void setComplex(Level level, boolean complex){
>+    protected void setComplex(Level level, boolean complex){       
>         boolean isAlreadyComplex = level.isComplex;
>-        level.setComplex(complex);
>+        super.setComplex(level, complex);
>         if(complex && !isAlreadyComplex){
>-            if(complex && level.jsonObjectBuilder == null){
>+            if(level.jsonObjectBuilder == null){
>                 level.jsonObjectBuilder = Json.createObjectBuilder();
>             }
>         }
>     }
>     
>-    @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
>-                setComplex(position, true);                                
>-            }
>-                      
>-            String keyName = getKeyName(xPathFragment);
>-           
>-            if(position.isCollection && position.isEmptyCollection() ){
>-                position.setKeyName(keyName);
>-            }else{
>-                newLevel.setKeyName(keyName);    
>-            }
>-            position = newLevel;   
>-            isLastEventStart = true;
>-        }
>-    }
>-       
>-    /**
>-     * 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();
>-                     setComplex(position, false);
>-                     ((Level)position.parentLevel).getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());                     
>-                 }else{ 
>-                     if(isLastEventStart){                         
>-                         setComplex(position, 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 endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
>-        if(position != null){
>-            if(isLastEventStart){
>-                setComplex(position, true);
>-            }
>-            if(position.isComplex){
>-                popAndSetInParentBuilder();
>-            }else{
>-                position = (Level) position.parentLevel;
>-            }            
>-            isLastEventStart = false;          
>-        }
>+    protected void writeEmptyCollection(Level level, String keyName){
>+        level.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
>     }
>-    
>-    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 = (Level) position.parentLevel;         
>-        }       
>-        addValue(currentLevel, keyName, value, schemaType);
>-        isLastEventStart = false;
>-        if(textWrapperOpened){    
>-             endElement(textWrapperFragment, namespaceResolver);
>-        }    
>-    }
>-    
>-    private void addValue(Level currentLevel, String keyName, Object value, QName schemaType){        
>-        if(currentLevel.isCollection()){
>-            currentLevel.setEmptyCollection(false);            
>-            addValueToArrayBuilder(currentLevel.getJsonArrayBuilder(), value, schemaType);
>-        } else {
>-            JsonObjectBuilder builder = currentLevel.getJsonObjectBuilder();
>-            addValueToObjectBuilder(builder, keyName, value, schemaType);            
>-        }
>-    }
>-    
>-    private void addValueToObjectBuilder(JsonObjectBuilder jsonObjectBuilder, String keyName, Object value, QName schemaType){
>+    protected void addValueToObject(Level level, String keyName, Object value, QName schemaType){
>+        JsonObjectBuilder jsonObjectBuilder = level.getJsonObjectBuilder();
>         if(value == NULL){
>             jsonObjectBuilder.addNull(keyName);
>         }else if(value instanceof Integer){
>@@ -297,7 +141,8 @@ public class JsonBuilderRecord extends JsonRecord {
>         }
>     }
>     
>-    private void addValueToArrayBuilder(JsonArrayBuilder jsonArrayBuilder, Object value, QName schemaType){
>+    protected void addValueToArray(Level level, Object value, QName schemaType){
>+        JsonArrayBuilder jsonArrayBuilder = level.getJsonArrayBuilder();
>         if(value == NULL){
>             jsonArrayBuilder.addNull();
>         }else if(value instanceof Integer){
>@@ -341,8 +186,8 @@ public class JsonBuilderRecord extends JsonRecord {
>         private JsonObjectBuilder jsonObjectBuilder;
>         private JsonArrayBuilder jsonArrayBuilder;
>         
>-        public Level(boolean isCollection, Level parentLevel) {
>-            super(isCollection, parentLevel);
>+        public Level(boolean isCollection, Level position) {
>+            super(isCollection, position);
>         }
>      
>         public void setCollection(boolean isCollection) {
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonGeneratorRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonGeneratorRecord.java
>index ddc69d2..e3bf148 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonGeneratorRecord.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonGeneratorRecord.java
>@@ -12,24 +12,18 @@
>  ******************************************************************************/
> package org.eclipse.persistence.oxm.record;
> 
>-import java.io.IOException;
>-import java.io.StringWriter;
> import java.math.BigDecimal;
> import java.math.BigInteger;
> 
> import javax.json.stream.JsonGenerator;
> import javax.xml.namespace.QName;
> 
>-import org.eclipse.persistence.exceptions.XMLMarshalException;
> import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
> import org.eclipse.persistence.internal.oxm.ConversionManager;
>-import org.eclipse.persistence.internal.oxm.NamespaceResolver;
>-import org.eclipse.persistence.internal.oxm.XPathFragment;
> import org.eclipse.persistence.internal.oxm.XMLConversionManager;
> 
>-public class JsonGeneratorRecord extends JsonRecord {
>+public class JsonGeneratorRecord extends JsonRecord<JsonRecord.Level> {
> 
>-    private Level position;    
>     private JsonGenerator jsonGenerator;
>     private String rootKeyName;
>           
>@@ -39,69 +33,40 @@ public class JsonGeneratorRecord extends JsonRecord {
>         this.rootKeyName = rootKeyName;
>     }
>     
>-    @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);
>-            rootLevel.setKeyName(rootKeyName);
>-            position = rootLevel;
>-            setComplex(position, true);
>-        }
>-    }
>-
>-    @Override
>-    public void endDocument() {        
>-        if(position != null){
>-            jsonGenerator.writeEnd(); 
>-            position = position.parentLevel;
>-        }
>+    protected void startRootObject(){
>+        super.startRootObject();        
>+        position.setKeyName(rootKeyName);
>+        setComplex(position, true);
>     }
>-    
>-    private void popAndSetInParentBuilder(){
>+   
>+    protected void finishLevel(){
>         if(!(position.isCollection && position.isEmptyCollection() && position.getKeyName() == null)){
>             jsonGenerator.writeEnd(); 
>         }
>-        position = position.parentLevel;      
>-    }    
>-    
>-    public void startCollection() {
>-        if(position == null){
>-             isRootArray = true;              
>-             Level rootLevel = new Level(true, null); 
>-             position = rootLevel;
>-             if(rootKeyName != null){
>-                jsonGenerator.writeStartArray(rootKeyName);
>-             }else{
>-                 jsonGenerator.writeStartArray();
>-             }
>-        } else {            
>-            if(isLastEventStart){
>-                setComplex(position, true);         
>-            }            
>-            Level level = new Level(true, position);            
>-            position = level;
>-        }      
>-        isLastEventStart = false;
>+        super.finishLevel();
>+    }   
>+  
>+    protected void startRootLevelCollection(){
>+        if(rootKeyName != null){
>+            jsonGenerator.writeStartArray(rootKeyName);
>+         }else{
>+             jsonGenerator.writeStartArray();
>+         }
>     }
>-    
>+
>     @Override
>     public void endCollection() {        
>-         popAndSetInParentBuilder();    
>+        finishLevel();    
>     }
> 
>-    private void setComplex(Level level, boolean complex){
>+    protected void setComplex(Level level, boolean complex){
>         boolean isAlreadyComplex = level.isComplex;
>-        level.setComplex(complex);
>+        super.setComplex(level, complex);
>         if(complex && !isAlreadyComplex){
>             Level parentLevel = level.parentLevel;
>+            if(parentLevel != null && parentLevel.isCollection && parentLevel.isEmptyCollection()){
>+                parentLevel.setEmptyCollection(false);
>+            }
>             if((parentLevel != null && parentLevel.isCollection && !parentLevel.isEmptyCollection()) || level.keyName == null){
>                 jsonGenerator.writeStartObject();                    
>             }else{
>@@ -110,123 +75,16 @@ public class JsonGeneratorRecord extends JsonRecord {
>         }
>     }
>     
>-    @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
>-                setComplex(position, true);
>-            }
>-                      
>-            String keyName = getKeyName(xPathFragment);
>-           
>-            if(position.isCollection && position.isEmptyCollection() ){
>-                position.setKeyName(keyName);
>-                jsonGenerator.writeStartArray(keyName);
>-                position.setEmptyCollection(false);
>-            }else{
>-                newLevel.setKeyName(keyName);    
>-            }
>-            position = newLevel;   
>-            isLastEventStart = true;
>-        }
>-    }    
>-    
>-    /**
>-     * 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();
>-                     setComplex(position, false);
>-                     jsonGenerator.writeStartArray(keyName);
>-                     jsonGenerator.writeEnd();
>-                 }else{ 
>-                     if(isLastEventStart){
>-                         setComplex(position, true);
>-                     }                 
>-                     String keyName =  getKeyName(xPathFragment);
>-                     if(keyName != null){
>-                         jsonGenerator.writeStartArray(keyName);
>-                         jsonGenerator.writeEnd();
>-                     }
>-                 }
>-                 isLastEventStart = false;   
>-             }
>-                  
>-             return true;
>-         }else{
>-             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
>-         }
>-    } 
>-    @Override
>-    public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
>-        if(position != null){
>-            if(isLastEventStart){
>-                setComplex(position, true);
>-            }
>-            if(position.isComplex){
>-                popAndSetInParentBuilder();
>-            }else{
>-                position = position.parentLevel;
>-            }            
>-            isLastEventStart = 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;         
>-        }
>-        addValue(currentLevel, keyName, value, schemaType);
>-        isLastEventStart = false;
>-        if(textWrapperOpened){    
>-             endElement(textWrapperFragment, namespaceResolver);
>-        }    
>+    protected void startEmptyCollection(){
>+       jsonGenerator.writeStartArray(position.keyName);
>     }
>-    private void addValue(Level currentLevel, String keyName, Object value, QName schemaType){        
>-        if(currentLevel.isCollection()){
>-            currentLevel.setEmptyCollection(false);
>-            addValueToArray(value, schemaType);            
>-        } else {
>-            addValueToObject(keyName, value, schemaType);
>-            
>-        }
>+
>+    protected void writeEmptyCollection(Level level, String keyName){
>+        jsonGenerator.writeStartArray(keyName);
>+        jsonGenerator.writeEnd();
>     }
>     
>-    private void addValueToObject(String keyName, Object value, QName schemaType){
>+    protected void addValueToObject(Level level, String keyName, Object value, QName schemaType){
>         
>         if(value == NULL){
>             jsonGenerator.writeNull(keyName);            
>@@ -262,7 +120,7 @@ public class JsonGeneratorRecord extends JsonRecord {
>         }
>     }
>     
>-    private void addValueToArray(Object value, QName schemaType){
>+    protected void addValueToArray(Level level, Object value, QName schemaType){
>         if(value == NULL){            
>             jsonGenerator.writeNull();
>         }else if(value instanceof Integer){
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonRecord.java
>index 718cccc..134781d 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonRecord.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonRecord.java
>@@ -12,8 +12,11 @@
>  ******************************************************************************/
> package org.eclipse.persistence.oxm.record;
> 
>+import java.io.IOException;
>+import java.io.StringWriter;
> import java.util.List;
> 
>+import javax.json.Json;
> import javax.xml.namespace.QName;
> 
> import org.eclipse.persistence.exceptions.XMLMarshalException;
>@@ -39,8 +42,9 @@ import org.xml.sax.Locator;
> import org.xml.sax.SAXException;
> import org.xml.sax.ext.LexicalHandler;
> 
>-public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> {
>+public abstract class JsonRecord<T extends JsonRecord.Level> extends MarshalRecord <XMLMarshaller> {
> 
>+    protected T position;    
>     protected CharacterEscapeHandler characterEscapeHandler;
>     protected String attributePrefix;
>     protected boolean isRootArray;
>@@ -60,6 +64,127 @@ public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> {
>         characterEscapeHandler = marshaller.getCharacterEscapeHandler();
>     }
>        
>+    
>+    @Override
>+    public void startDocument(String encoding, String version) {      
>+        if(isRootArray){
>+            if(position == null){
>+                startCollection();
>+            }
>+            position.setEmptyCollection(false);
>+            
>+            position = createNewLevel(false, position);
>+            
>+            isLastEventStart = true;
>+        }else{            
>+            startRootObject();            
>+        }
>+    }
>+    
>+    protected T createNewLevel(boolean collection, T parentLevel){
>+        return (T)new Level(collection, position);        
>+    }
>+   
>+    protected void startRootObject(){
>+        position = createNewLevel(false, null);        
>+    }
>+    
>+    
>+    @Override    
>+    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
>+        super.openStartElement(xPathFragment, namespaceResolver);
>+        if(position != null){
>+            T newLevel = createNewLevel(false, position);            
>+            
>+            if(isLastEventStart){                              
>+                //this means 2 startevents in a row so the last this is a complex object
>+                setComplex(position, true);
>+            }
>+                      
>+            String keyName = getKeyName(xPathFragment);
>+           
>+            if(position.isCollection && position.isEmptyCollection() ){
>+                position.setKeyName(keyName);                
>+                startEmptyCollection();
>+            }else{
>+                newLevel.setKeyName(keyName);    
>+            }
>+            position = newLevel;   
>+            isLastEventStart = true;
>+        }
>+    }     
>+    
>+    protected void startEmptyCollection(){}
>+    
>+    /**
>+     * 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();
>+                     setComplex(position, false);
>+                     writeEmptyCollection((T)position.parentLevel, keyName);
>+                 }else{ 
>+                     if(isLastEventStart){                         
>+                         setComplex(position, true);
>+                     }                 
>+                     String keyName =  getKeyName(xPathFragment);
>+                     if(keyName != null){
>+                         writeEmptyCollection(position, keyName);
>+                     }
>+                 }
>+                 isLastEventStart = false;   
>+             }
>+                  
>+             return true;
>+         }else{
>+             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
>+         }
>+    }
>+      
>+    protected abstract void writeEmptyCollection(T level, String keyName);
>+    
>+    @Override
>+    public void endDocument() {
>+        if(position != null){
>+            finishLevel();          
>+        }
>+    }
>+    
>+    protected void finishLevel(){
>+        position = (T)position.parentLevel; 
>+    }
>+    
>+    public void startCollection() {
>+        if(position == null){
>+             isRootArray = true;              
>+             position = createNewLevel(true, null);
>+             startRootLevelCollection();             
>+        } else {            
>+            if(isLastEventStart){
>+                setComplex((T)position, true);           
>+            }            
>+            position = createNewLevel(true, position); 
>+        }      
>+        isLastEventStart = false;
>+    }
>+    
>+    protected void setComplex(T level, boolean complex){
>+        level.setComplex(complex);
>+    }
>+    
>+    protected abstract void startRootLevelCollection();
>+    
>     protected String getKeyName(XPathFragment xPathFragment){
>         String keyName = xPathFragment.getLocalName(); 
>        
>@@ -82,7 +207,7 @@ public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> {
> 
>         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;
>@@ -239,8 +364,63 @@ public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> {
>         return false;
>     }        
>     
>-    public abstract void writeValue(Object value, QName schemaType, boolean isAttribute);
>-
>+   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;
>+        }
>+      
>+        T currentLevel = position;
>+        String keyName = position.getKeyName();
>+        if(!position.isComplex){           
>+            currentLevel = (T)position.parentLevel;         
>+        }
>+        addValue(currentLevel, keyName, value, schemaType);
>+        isLastEventStart = false;
>+        if(textWrapperOpened){    
>+             endElement(textWrapperFragment, namespaceResolver);
>+        }    
>+    }
>+   
>+   @Override
>+   public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
>+       if(position != null){
>+           if(isLastEventStart){
>+               setComplex(position, true);
>+           }
>+           if(position.isComplex){
>+               finishLevel();
>+           }else{
>+               position = (T) position.parentLevel;
>+           }            
>+           isLastEventStart = false;          
>+       }
>+   }
>+   
>+   private void addValue(T currentLevel, String keyName, Object value, QName schemaType){        
>+       if(currentLevel.isCollection()){
>+           addValueToArray(currentLevel, value, schemaType);
>+           currentLevel.setEmptyCollection(false);            
>+       } else {            
>+           addValueToObject(currentLevel, keyName, value, schemaType);            
>+       }
>+   }
>+   protected abstract void addValueToObject(T currentLevel, String keyName, Object value, QName schemaType);
>+
>+   protected abstract void addValueToArray(T currentLevel,  Object value, QName schemaType);
>+   
>     @Override
>     public void cdata(String value) {
>         characters(value);

Actions: View | Diff

Attachments on bug 411382: 233765 | 233768 | 233805 | 233848