Attachment #233848 for bug #411382

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




 ******************************************************************************/
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.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<JsonBuilderRecord.Level> {
 
    private Level position;
    private JsonObjectBuilder rootJsonObjectBuilder;
    private JsonArrayBuilder rootJsonArrayBuilder;
 
    
    public JsonBuilderRecord(){
        super();
        isLastEventStart = false;

        rootJsonArrayBuilder = jsonArrayBuilder;
        isRootArray = true;
    }
     
    protected Level createNewLevel(boolean collection, Level parentLevel){
      return new Level(collection, position);       
        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 void startRootObject(){
        super.startRootObject();                
        position.setJsonObjectBuilder(rootJsonObjectBuilder);
        setComplex(position, true);
                popAndSetInParentBuilder();
            }else{
                //this is the root level list case
                position = (Level) position.parentLevel;
            }
        }
    }
       
    protected void finishLevel(){
        if(!(position.isCollection && position.isEmptyCollection() && position.getKeyName() == null)){
            
            Level parentLevel = (Level) position.parentLevel;
    
            if(parentLevel != null){                  
                if(parentLevel.isCollection){
                    if(position.isCollection){
                        parentLevel.getJsonArrayBuilder().add(position.getJsonArrayBuilder());
                    }else{                   
                        parentLevel.getJsonArrayBuilder().add(position.getJsonObjectBuilder());
                    }
      
        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{
                    if(position.isCollection){                    
                        parentLevel.getJsonObjectBuilder().add(position.getKeyName(), position.getJsonArrayBuilder());
                    }else{
                        parentLevel.getJsonObjectBuilder().add(position.getKeyName(), position.getJsonObjectBuilder());
                    }
                }
            }
        }
        super.finishLevel();      
    }    
    
    protected void startRootLevelCollection(){
        if(rootJsonArrayBuilder == null){
            rootJsonArrayBuilder = Json.createArrayBuilder();
       }
       position.setJsonArrayBuilder(rootJsonArrayBuilder); 
                  rootJsonArrayBuilder = Json.createArrayBuilder();
             }
             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
             position = rootLevel;
        } else {            
            if(isLastEventStart){
                setComplex(position, true);           
            }            
            Level level = new Level(true, position);            
            position = level;
        }      
        isLastEventStart = false;
    }

    @Override
    public void endCollection() {
        finishLevel();    
    }
    
    protected void setComplex(Level level, boolean complex){       
        boolean isAlreadyComplex = level.isComplex;
        super.setComplex(level, complex);
        if(complex && !isAlreadyComplex){
            if(level.jsonObjectBuilder == null){
                level.jsonObjectBuilder = Json.createObjectBuilder();
            }
        }
    }
    
    protected void writeEmptyCollection(Level level, String keyName){
        level.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
        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;          
        }
    }
    
    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;
        }
      
    protected void addValueToObject(Level level, String keyName, Object value, QName schemaType){
        JsonObjectBuilder jsonObjectBuilder = level.getJsonObjectBuilder();
        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){
        if(value == NULL){
            jsonObjectBuilder.addNull(keyName);
        }else if(value instanceof Integer){

        }
    }
    
    protected void addValueToArray(Level level, Object value, QName schemaType){
        JsonArrayBuilder jsonArrayBuilder = level.getJsonArrayBuilder();
        if(value == NULL){
            jsonArrayBuilder.addNull();
        }else if(value instanceof Integer){

        private JsonObjectBuilder jsonObjectBuilder;
        private JsonArrayBuilder jsonArrayBuilder;
        
        public Level(boolean isCollection, Level position) {
            super(isCollection, position);
        }
     
        public void setCollection(boolean isCollection) {




 ******************************************************************************/
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<JsonRecord.Level> {

    private Level position;    
    private JsonGenerator jsonGenerator;
    private String rootKeyName;
          

        this.rootKeyName = rootKeyName;
    }
    
    protected void startRootObject(){
        super.startRootObject();        
        position.setKeyName(rootKeyName);
        setComplex(position, true);
                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 finishLevel(){
        if(!(position.isCollection && position.isEmptyCollection() && position.getKeyName() == null)){
            jsonGenerator.writeEnd(); 
        }
        super.finishLevel();
    }   
  
    protected void startRootLevelCollection(){
        if(rootKeyName != null){
            jsonGenerator.writeStartArray(rootKeyName);
         }else{
             jsonGenerator.writeStartArray();
         }
                jsonGenerator.writeStartArray(rootKeyName);
             }else{
                 jsonGenerator.writeStartArray();
             }
        } else {            
            if(isLastEventStart){
                setComplex(position, true);         
            }            
            Level level = new Level(true, position);            
            position = level;
        }      
        isLastEventStart = false;
    }

    @Override
    public void endCollection() {        
        finishLevel();    
    }

    protected void setComplex(Level level, boolean complex){
        boolean isAlreadyComplex = level.isComplex;
        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{

        }
    }
    
    protected void startEmptyCollection(){
       jsonGenerator.writeStartArray(position.keyName);
        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 writeEmptyCollection(Level level, String keyName){
        jsonGenerator.writeStartArray(keyName);
        jsonGenerator.writeEnd();
        } else {
            addValueToObject(keyName, value, schemaType);
            
        }
    }
    
    protected void addValueToObject(Level level, String keyName, Object value, QName schemaType){
        
        if(value == NULL){
            jsonGenerator.writeNull(keyName);            

        }
    }
    
    protected void addValueToArray(Level level, Object value, QName schemaType){
        if(value == NULL){            
            jsonGenerator.writeNull();
        }else if(value instanceof Integer){

Lines 12-19 Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonRecord.java (-4 / +184 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.oxm.record;	13	package org.eclipse.persistence.oxm.record;
14		14
		15	import java.io.IOException;
		16	import java.io.StringWriter;
15	import java.util.List;	17	import java.util.List;
16		18
		19	import javax.json.Json;
17	import javax.xml.namespace.QName;	20	import javax.xml.namespace.QName;
18		21
19	import org.eclipse.persistence.exceptions.XMLMarshalException;	22	import org.eclipse.persistence.exceptions.XMLMarshalException;
Lines 39-46 import org.xml.sax.Locator; Link Here
39	import org.xml.sax.SAXException;	42	import org.xml.sax.SAXException;
40	import org.xml.sax.ext.LexicalHandler;	43	import org.xml.sax.ext.LexicalHandler;
41		44
42	public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> {	45	public abstract class JsonRecord<T extends JsonRecord.Level> extends MarshalRecord <XMLMarshaller> {
43		46
		47	protected T position;
44	protected CharacterEscapeHandler characterEscapeHandler;	48	protected CharacterEscapeHandler characterEscapeHandler;
45	protected String attributePrefix;	49	protected String attributePrefix;
46	protected boolean isRootArray;	50	protected boolean isRootArray;
Lines 60-65 public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> { Link Here
60	characterEscapeHandler = marshaller.getCharacterEscapeHandler();	64	characterEscapeHandler = marshaller.getCharacterEscapeHandler();
61	}	65	}
62		66
		67
		68	@Override
		69	public void startDocument(String encoding, String version) {
		70	if(isRootArray){
		71	if(position == null){
		72	startCollection();
		73	}
		74	position.setEmptyCollection(false);
		75
		76	position = createNewLevel(false, position);
		77
		78	isLastEventStart = true;
		79	}else{
		80	startRootObject();
		81	}
		82	}
		83
		84	protected T createNewLevel(boolean collection, T parentLevel){
		85	return (T)new Level(collection, position);
		86	}
		87
		88	protected void startRootObject(){
		89	position = createNewLevel(false, null);
		90	}
		91
		92
		93	@Override
		94	public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
		95	super.openStartElement(xPathFragment, namespaceResolver);
		96	if(position != null){
		97	T newLevel = createNewLevel(false, position);
		98
		99	if(isLastEventStart){
		100	//this means 2 startevents in a row so the last this is a complex object
		101	setComplex(position, true);
		102	}
		103
		104	String keyName = getKeyName(xPathFragment);
		105
		106	if(position.isCollection && position.isEmptyCollection() ){
		107	position.setKeyName(keyName);
		108	startEmptyCollection();
		109	}else{
		110	newLevel.setKeyName(keyName);
		111	}
		112	position = newLevel;
		113	isLastEventStart = true;
		114	}
		115	}
		116
		117	protected void startEmptyCollection(){}
		118
		119	/**
		120	* Handle marshal of an empty collection.
		121	* @param xPathFragment
		122	* @param namespaceResolver
		123	* @param openGrouping if grouping elements should be marshalled for empty collections
		124	* @return
		125	*/
		126	public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) {
		127
		128	if(marshaller.isMarshalEmptyCollections()){
		129	super.emptyCollection(xPathFragment, namespaceResolver, true);
		130
131	if (null != xPathFragment) {
132
133	if(xPathFragment.isSelfFragment() \|\| xPathFragment.nameIsText()){
134	String keyName = position.getKeyName();
135	setComplex(position, false);
136	writeEmptyCollection((T)position.parentLevel, keyName);
137	}else{
138	if(isLastEventStart){
139	setComplex(position, true);
140	}
141	String keyName = getKeyName(xPathFragment);
142	if(keyName != null){
143	writeEmptyCollection(position, keyName);
144	}
145	}
146	isLastEventStart = false;
147	}
148
149	return true;
150	}else{
151	return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
152	}
153	}
154
155	protected abstract void writeEmptyCollection(T level, String keyName);
156
157	@Override
158	public void endDocument() {
159	if(position != null){
160	finishLevel();
161	}
162	}
163
164	protected void finishLevel(){
165	position = (T)position.parentLevel;
166	}
167
168	public void startCollection() {
169	if(position == null){
170	isRootArray = true;
171	position = createNewLevel(true, null);
172	startRootLevelCollection();
173	} else {
174	if(isLastEventStart){
175	setComplex((T)position, true);
176	}
177	position = createNewLevel(true, position);
178	}
179	isLastEventStart = false;
180	}
181
182	protected void setComplex(T level, boolean complex){
183	level.setComplex(complex);
184	}
185
186	protected abstract void startRootLevelCollection();
187
63	protected String getKeyName(XPathFragment xPathFragment){	188	protected String getKeyName(XPathFragment xPathFragment){
64	String keyName = xPathFragment.getLocalName();	189	String keyName = xPathFragment.getLocalName();
65		190
Lines 82-88 public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> { Link Here
82		207
83	return keyName;	208	return keyName;
84	}	209	}
85		210
86	public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, Object value, QName schemaType){	211	public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, Object value, QName schemaType){
87	if(xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI){	212	if(xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI){
88	return;	213	return;
Lines 239-246 public abstract class JsonRecord extends MarshalRecord <XMLMarshaller> { Link Here
239	return false;	364	return false;
240	}	365	}
241		366
242	public abstract void writeValue(Object value, QName schemaType, boolean isAttribute);	367	public void writeValue(Object value, QName schemaType, boolean isAttribute) {
243		368
		369	if (characterEscapeHandler != null && value instanceof String) {
		370	try {
		371	StringWriter stringWriter = new StringWriter();
		372	characterEscapeHandler.escape(((String)value).toCharArray(), 0, ((String)value).length(), isAttribute, stringWriter);
		373	value = stringWriter.toString();
		374	} catch (IOException e) {
		375	throw XMLMarshalException.marshalException(e);
		376	}
		377	}
		378
		379	boolean textWrapperOpened = false;
		380	if(!isLastEventStart){
		381	openStartElement(textWrapperFragment, namespaceResolver);
		382	textWrapperOpened = true;
		383	}
		384
		385	T currentLevel = position;
		386	String keyName = position.getKeyName();
		387	if(!position.isComplex){
		388	currentLevel = (T)position.parentLevel;
		389	}
		390	addValue(currentLevel, keyName, value, schemaType);
		391	isLastEventStart = false;
		392	if(textWrapperOpened){
		393	endElement(textWrapperFragment, namespaceResolver);
		394	}
		395	}
		396
		397	@Override
		398	public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
		399	if(position != null){
		400	if(isLastEventStart){
		401	setComplex(position, true);
		402	}
		403	if(position.isComplex){
		404	finishLevel();
		405	}else{
		406	position = (T) position.parentLevel;
		407	}
		408	isLastEventStart = false;
		409	}
		410	}
		411
		412	private void addValue(T currentLevel, String keyName, Object value, QName schemaType){
		413	if(currentLevel.isCollection()){
		414	addValueToArray(currentLevel, value, schemaType);
		415	currentLevel.setEmptyCollection(false);
		416	} else {
		417	addValueToObject(currentLevel, keyName, value, schemaType);
		418	}
		419	}
		420	protected abstract void addValueToObject(T currentLevel, String keyName, Object value, QName schemaType);
		421
		422	protected abstract void addValueToArray(T currentLevel, Object value, QName schemaType);
		423
244	@Override	424	@Override
245	public void cdata(String value) {	425	public void cdata(String value) {
246	characters(value);	426	characters(value);

Return to bug 411382