Attachment #129286 for bug #269262




import org.eclipse.persistence.oxm.XMLDescriptor;
import org.eclipse.persistence.oxm.XMLMarshaller;
import org.eclipse.persistence.oxm.XMLRoot;
import org.eclipse.persistence.oxm.mappings.UnmarshalKeepAsElementPolicy;
import org.eclipse.persistence.oxm.mappings.XMLAnyObjectMapping;
import org.eclipse.persistence.oxm.record.MarshalRecord;
import org.eclipse.persistence.oxm.record.UnmarshalRecord;

                xmlDescriptor = xmlContext.getDescriptor(qname);
            }
            workingDescriptor = xmlDescriptor;
            UnmarshalKeepAsElementPolicy policy = xmlAnyObjectMapping.getKeepAsElementPolicy();
            if ((xmlDescriptor == null) && (policy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT)) {
                //setup handler stuff
                SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
                builder.setOwningRecord(unmarshalRecord);
                try {
                    String namespaceURI = "";
                    if (xPathFragment.getNamespaceURI() != null) {
                        namespaceURI = xPathFragment.getNamespaceURI();
                    }
                    String qName = xPathFragment.getLocalName();
                    if (xPathFragment.getPrefix() != null) {
                        qName = xPathFragment.getPrefix() + ":" + qName;
                    }

                    builder.startElement(namespaceURI, xPathFragment.getLocalName(), qName, atts);
                    unmarshalRecord.getXMLReader().setContentHandler(builder);
                } catch (SAXException ex) {
                }
            }            
            
            if (null == xmlDescriptor) {
                //need to give to special handler, let it find out what to do depending on if this is simple or complex content
                AnyMappingContentHandler handler = new AnyMappingContentHandler(unmarshalRecord, xmlAnyObjectMapping.usesXMLRoot());

                }
            }
        } else {
            SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();

            UnmarshalKeepAsElementPolicy keepAsElementPolicy = xmlAnyObjectMapping.getKeepAsElementPolicy();

            if ((keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) && (builder.getNodes().size() != 0)) {
                Object node = builder.getNodes().pop();
                if(xmlAnyObjectMapping.getConverter() != null) {
                    node = xmlAnyObjectMapping.getConverter().convertDataValueToObjectValue(node, unmarshalRecord.getSession(), unmarshalRecord.getUnmarshaller());
                }
                unmarshalRecord.setAttributeValue(node, xmlAnyObjectMapping);
            } else {
                // TEXT VALUE             
                endElementProcessText(unmarshalRecord, xPathFragment);
            }
        }
    }


            if (generatedNamespace != null) {
                marshalRecord.attribute(XMLConstants.XMLNS_URL, XMLConstants.XMLNS_URL, XMLConstants.XMLNS + ":" + generatedNamespace.getPrefix(), generatedNamespace.getNamespaceURI());
            }

            if (qname != null) {
                String prefix = marshalRecord.getNamespaceResolver().resolveNamespaceURI(qname.getNamespaceURI());
                if ((prefix == null) || prefix.equals("")) {

            }
        }

        if (value instanceof String) {
            marshalRecord.characters((String) value);
        } else {
            marshalRecord.node((org.w3c.dom.Node) value, marshalRecord.getNamespaceResolver());
        }

        if (xmlRootFragment != null) {
            marshalRecord.endElement(xmlRootFragment, namespaceResolver);

    public XMLAnyObjectMapping getMapping() {
        return xmlAnyObjectMapping;
    }
    
}




    private boolean useXMLRoot;
    private boolean areOtherMappingInThisContext = true;
    private XMLConverter converter;
    private UnmarshalKeepAsElementPolicy keepAsElementPolicy;

    public XMLAnyObjectMapping() {
        useXMLRoot = false;

        int i = 0;
        int length = unmappedChildren.size();
        while (iter.hasNext()) {
            Object objectValue = null;
            org.w3c.dom.Node next = (Node) iter.next();
            if (next.getNodeType() == Node.TEXT_NODE) {
                if ((i == (length - 1)) || (next.getNodeValue().trim().length() > 0)) {
                	objectValue = next.getNodeValue();
                	if(getConverter() != null) {
                		objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
                	}

                if (!useXMLRoot) {
                    referenceDescriptor = getDescriptor(nestedRecord, session, null);

                    if (referenceDescriptor != null && keepAsElementPolicy != UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) {
                        ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
                        objectValue = builder.buildObject(query, nestedRecord, joinManager);
                    	if(getConverter() != null) {
                    		objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
                    	}
                        return objectValue;
                    } else {
                        if (keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) {
                            XMLPlatformFactory.getInstance().getXMLPlatform().namespaceQualifyFragment((Element) next);
                            objectValue = next;
                            if(getConverter() != null) {
                                objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
                            }
                            return objectValue;
                        }
                    }
                } else {
                    String schemaType = ((Element) next).getAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);

                    }
                    if (referenceDescriptor != null) {
                        ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
                        objectValue = builder.buildObject(query, nestedRecord, joinManager);
                        Object updated = ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objectValue, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false);
                    	if(getConverter() != null) {
                    		updated = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
                    	}
                        return updated;
                    } else if ((referenceDescriptor != null) && (getKeepAsElementPolicy() != UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT)) {
                        ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
                        objectValue = builder.buildObject(query, nestedRecord, joinManager);
                        Object updated = ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objectValue, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false);

                        if(getConverter() != null) {
                            updated = getConverter().convertDataValueToObjectValue(updated, session, record.getUnmarshaller());
                        }                       
                        return updated;
                    } else {
                        Object value = null;
                        Node textchild = ((Element) next).getFirstChild();

    public void setConverter(XMLConverter converter) {
    	this.converter = converter;
    }

    public UnmarshalKeepAsElementPolicy getKeepAsElementPolicy() {
        return keepAsElementPolicy;
    }

    public void setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy keepAsElementPolicy) {
        this.keepAsElementPolicy = keepAsElementPolicy;
    }
}




import org.eclipse.persistence.oxm.annotations.*;
import org.eclipse.persistence.jaxb.javamodel.Helper;
import org.eclipse.persistence.jaxb.javamodel.JavaClass;
import org.eclipse.persistence.jaxb.javamodel.JavaField;
import org.eclipse.persistence.jaxb.javamodel.JavaHasAnnotations;
import org.eclipse.persistence.jaxb.javamodel.JavaMethod;
import org.eclipse.persistence.jaxb.JAXBEnumTypeConverter;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.jaxb.JaxbClassLoader;
import org.eclipse.persistence.internal.jaxb.DomHandlerConverter;
import org.eclipse.persistence.internal.jaxb.MultiArgInstantiationPolicy;

import org.eclipse.persistence.mappings.AttributeAccessor;
import org.eclipse.persistence.mappings.DatabaseMapping;


import org.eclipse.persistence.oxm.*;
import org.eclipse.persistence.oxm.mappings.*;
import org.eclipse.persistence.oxm.mappings.converters.XMLRootConverter;

                if (property.isSwaAttachmentRef() || property.isMtomAttachment()) {
                    generateBinaryMapping(property, descriptor, namespaceInfo);
                } else {
                    if (referenceClass.getQualifiedName().equals("java.lang.Object")) {
                        generateAnyObjectMapping(property, descriptor, namespaceInfo);
                    } else {
                        generateDirectMapping(property, descriptor, namespaceInfo);
                    }
                }
            }
        }

        descriptor.addMapping(mapping);
    }
    
    public void generateAnyObjectMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
        XMLAnyObjectMapping mapping = new XMLAnyObjectMapping();
        mapping.setAttributeName(property.getPropertyName());
        if (property.isMethodProperty()) {
            mapping.setGetMethodName(property.getGetMethodName());
            mapping.setSetMethodName(property.getSetMethodName());
        }
        
        mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
        
        descriptor.addMapping(mapping);
    }
    
    protected boolean areEquals(JavaClass src, Class tgt) {
        if (src == null || tgt == null) {
            return false;

Return to bug 269262

Lines 30-35 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLAnyObjectMappingNodeValue.java (-5 / +41 lines)
30	import org.eclipse.persistence.oxm.XMLDescriptor;	30	import org.eclipse.persistence.oxm.XMLDescriptor;
31	import org.eclipse.persistence.oxm.XMLMarshaller;	31	import org.eclipse.persistence.oxm.XMLMarshaller;
32	import org.eclipse.persistence.oxm.XMLRoot;	32	import org.eclipse.persistence.oxm.XMLRoot;
		33	import org.eclipse.persistence.oxm.mappings.UnmarshalKeepAsElementPolicy;
33	import org.eclipse.persistence.oxm.mappings.XMLAnyObjectMapping;	34	import org.eclipse.persistence.oxm.mappings.XMLAnyObjectMapping;
34	import org.eclipse.persistence.oxm.record.MarshalRecord;	35	import org.eclipse.persistence.oxm.record.MarshalRecord;
35	import org.eclipse.persistence.oxm.record.UnmarshalRecord;	36	import org.eclipse.persistence.oxm.record.UnmarshalRecord;
Lines 187-193 Link Here
187	xmlDescriptor = xmlContext.getDescriptor(qname);	188	xmlDescriptor = xmlContext.getDescriptor(qname);
188	}	189	}
189	workingDescriptor = xmlDescriptor;	190	workingDescriptor = xmlDescriptor;
		191	UnmarshalKeepAsElementPolicy policy = xmlAnyObjectMapping.getKeepAsElementPolicy();
		192	if ((xmlDescriptor == null) && (policy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT)) {
		193	//setup handler stuff
		194	SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
		195	builder.setOwningRecord(unmarshalRecord);
		196	try {
		197	String namespaceURI = "";
		198	if (xPathFragment.getNamespaceURI() != null) {
		199	namespaceURI = xPathFragment.getNamespaceURI();
		200	}
		201	String qName = xPathFragment.getLocalName();
		202	if (xPathFragment.getPrefix() != null) {
		203	qName = xPathFragment.getPrefix() + ":" + qName;
		204	}
190		205
		206	builder.startElement(namespaceURI, xPathFragment.getLocalName(), qName, atts);
		207	unmarshalRecord.getXMLReader().setContentHandler(builder);
		208	} catch (SAXException ex) {
		209	}
		210	}
		211
191	if (null == xmlDescriptor) {	212	if (null == xmlDescriptor) {
192	//need to give to special handler, let it find out what to do depending on if this is simple or complex content	213	//need to give to special handler, let it find out what to do depending on if this is simple or complex content
193	AnyMappingContentHandler handler = new AnyMappingContentHandler(unmarshalRecord, xmlAnyObjectMapping.usesXMLRoot());	214	AnyMappingContentHandler handler = new AnyMappingContentHandler(unmarshalRecord, xmlAnyObjectMapping.usesXMLRoot());
Lines 230-237 Link Here
230	}	251	}
231	}	252	}
232	} else {	253	} else {
233	// TEXT VALUE	254	SAXFragmentBuilder builder = unmarshalRecord.getFragmentBuilder();
234	endElementProcessText(unmarshalRecord, xPathFragment);	255
		256	UnmarshalKeepAsElementPolicy keepAsElementPolicy = xmlAnyObjectMapping.getKeepAsElementPolicy();
		257
		258	if ((keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) && (builder.getNodes().size() != 0)) {
		259	Object node = builder.getNodes().pop();
		260	if(xmlAnyObjectMapping.getConverter() != null) {
		261	node = xmlAnyObjectMapping.getConverter().convertDataValueToObjectValue(node, unmarshalRecord.getSession(), unmarshalRecord.getUnmarshaller());
		262	}
		263	unmarshalRecord.setAttributeValue(node, xmlAnyObjectMapping);
		264	} else {
		265	// TEXT VALUE
		266	endElementProcessText(unmarshalRecord, xPathFragment);
		267	}
235	}	268	}
236	}	269	}
237		270
Lines 296-302 Link Here
296	if (generatedNamespace != null) {	329	if (generatedNamespace != null) {
297	marshalRecord.attribute(XMLConstants.XMLNS_URL, XMLConstants.XMLNS_URL, XMLConstants.XMLNS + ":" + generatedNamespace.getPrefix(), generatedNamespace.getNamespaceURI());	330	marshalRecord.attribute(XMLConstants.XMLNS_URL, XMLConstants.XMLNS_URL, XMLConstants.XMLNS + ":" + generatedNamespace.getPrefix(), generatedNamespace.getNamespaceURI());
298	}	331	}
299
300	if (qname != null) {	332	if (qname != null) {
301	String prefix = marshalRecord.getNamespaceResolver().resolveNamespaceURI(qname.getNamespaceURI());	333	String prefix = marshalRecord.getNamespaceResolver().resolveNamespaceURI(qname.getNamespaceURI());
302	if ((prefix == null) \|\| prefix.equals("")) {	334	if ((prefix == null) \|\| prefix.equals("")) {
Lines 309-315 Link Here
309	}	341	}
310	}	342	}
311		343
312	marshalRecord.characters((String) value);	344	if (value instanceof String) {
		345	marshalRecord.characters((String) value);
		346	} else {
		347	marshalRecord.node((org.w3c.dom.Node) value, marshalRecord.getNamespaceResolver());
		348	}
313		349
314	if (xmlRootFragment != null) {	350	if (xmlRootFragment != null) {
315	marshalRecord.endElement(xmlRootFragment, namespaceResolver);	351	marshalRecord.endElement(xmlRootFragment, namespaceResolver);
Lines 319-323 Link Here
319	public XMLAnyObjectMapping getMapping() {	355	public XMLAnyObjectMapping getMapping() {
320	return xmlAnyObjectMapping;	356	return xmlAnyObjectMapping;
321	}	357	}
322		358
323	}	359	}

Lines 160-165 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/mappings/XMLAnyObjectMapping.java (-4 / +32 lines)
160	private boolean useXMLRoot;	160	private boolean useXMLRoot;
161	private boolean areOtherMappingInThisContext = true;	161	private boolean areOtherMappingInThisContext = true;
162	private XMLConverter converter;	162	private XMLConverter converter;
		163	private UnmarshalKeepAsElementPolicy keepAsElementPolicy;
163		164
164	public XMLAnyObjectMapping() {	165	public XMLAnyObjectMapping() {
165	useXMLRoot = false;	166	useXMLRoot = false;
Lines 301-310 Link Here
301	int i = 0;	302	int i = 0;
302	int length = unmappedChildren.size();	303	int length = unmappedChildren.size();
303	while (iter.hasNext()) {	304	while (iter.hasNext()) {
		305	Object objectValue = null;
304	org.w3c.dom.Node next = (Node) iter.next();	306	org.w3c.dom.Node next = (Node) iter.next();
305	if (next.getNodeType() == Node.TEXT_NODE) {	307	if (next.getNodeType() == Node.TEXT_NODE) {
306	if ((i == (length - 1)) \|\| (next.getNodeValue().trim().length() > 0)) {	308	if ((i == (length - 1)) \|\| (next.getNodeValue().trim().length() > 0)) {
307	Object objectValue = next.getNodeValue();	309	objectValue = next.getNodeValue();
308	if(getConverter() != null) {	310	if(getConverter() != null) {
309	objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());	311	objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
310	}	312	}
Lines 320-332 Link Here
320	if (!useXMLRoot) {	322	if (!useXMLRoot) {
321	referenceDescriptor = getDescriptor(nestedRecord, session, null);	323	referenceDescriptor = getDescriptor(nestedRecord, session, null);
322		324
323	if (referenceDescriptor != null) {	325	if (referenceDescriptor != null && keepAsElementPolicy != UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) {
324	ObjectBuilder builder = referenceDescriptor.getObjectBuilder();	326	ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
325	Object objectValue = builder.buildObject(query, nestedRecord, joinManager);	327	objectValue = builder.buildObject(query, nestedRecord, joinManager);
326	if(getConverter() != null) {	328	if(getConverter() != null) {
327	objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());	329	objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
328	}	330	}
329	return objectValue;	331	return objectValue;
		332	} else {
		333	if (keepAsElementPolicy == UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT) {
		334	XMLPlatformFactory.getInstance().getXMLPlatform().namespaceQualifyFragment((Element) next);
		335	objectValue = next;
		336	if(getConverter() != null) {
		337	objectValue = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
		338	}
		339	return objectValue;
		340	}
330	}	341	}
331	} else {	342	} else {
332	String schemaType = ((Element) next).getAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);	343	String schemaType = ((Element) next).getAttributeNS(XMLConstants.SCHEMA_INSTANCE_URL, XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
Lines 355-366 Link Here
355	}	366	}
356	if (referenceDescriptor != null) {	367	if (referenceDescriptor != null) {
357	ObjectBuilder builder = referenceDescriptor.getObjectBuilder();	368	ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
358	Object objectValue = builder.buildObject(query, nestedRecord, joinManager);	369	objectValue = builder.buildObject(query, nestedRecord, joinManager);
359	Object updated = ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objectValue, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false);	370	Object updated = ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objectValue, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false);
360	if(getConverter() != null) {	371	if(getConverter() != null) {
361	updated = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());	372	updated = getConverter().convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller());
362	}	373	}
363	return updated;	374	return updated;
		375	} else if ((referenceDescriptor != null) && (getKeepAsElementPolicy() != UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT)) {
		376	ObjectBuilder builder = referenceDescriptor.getObjectBuilder();
		377	objectValue = builder.buildObject(query, nestedRecord, joinManager);
		378	Object updated = ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objectValue, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false);
		379
		380	if(getConverter() != null) {
		381	updated = getConverter().convertDataValueToObjectValue(updated, session, record.getUnmarshaller());
		382	}
		383	return updated;
364	} else {	384	} else {
365	Object value = null;	385	Object value = null;
366	Node textchild = ((Element) next).getFirstChild();	386	Node textchild = ((Element) next).getFirstChild();
Lines 691-694 Link Here
691	public void setConverter(XMLConverter converter) {	711	public void setConverter(XMLConverter converter) {
692	this.converter = converter;	712	this.converter = converter;
693	}	713	}
		714
		715	public UnmarshalKeepAsElementPolicy getKeepAsElementPolicy() {
		716	return keepAsElementPolicy;
		717	}
		718
		719	public void setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy keepAsElementPolicy) {
		720	this.keepAsElementPolicy = keepAsElementPolicy;
		721	}
694	}	722	}

Lines 28-38 Link Here

(-)moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/compiler/MappingsGenerator.java (-5 / +18 lines)
28	import org.eclipse.persistence.oxm.annotations.*;	28	import org.eclipse.persistence.oxm.annotations.*;
29	import org.eclipse.persistence.jaxb.javamodel.Helper;	29	import org.eclipse.persistence.jaxb.javamodel.Helper;
30	import org.eclipse.persistence.jaxb.javamodel.JavaClass;	30	import org.eclipse.persistence.jaxb.javamodel.JavaClass;
31	import org.eclipse.persistence.jaxb.javamodel.JavaField;
32	import org.eclipse.persistence.jaxb.javamodel.JavaHasAnnotations;
33	import org.eclipse.persistence.jaxb.javamodel.JavaMethod;	31	import org.eclipse.persistence.jaxb.javamodel.JavaMethod;
34	import org.eclipse.persistence.jaxb.JAXBEnumTypeConverter;	32	import org.eclipse.persistence.jaxb.JAXBEnumTypeConverter;
35	import org.eclipse.persistence.internal.helper.ClassConstants;
36	import org.eclipse.persistence.internal.jaxb.JaxbClassLoader;	33	import org.eclipse.persistence.internal.jaxb.JaxbClassLoader;
37	import org.eclipse.persistence.internal.jaxb.DomHandlerConverter;	34	import org.eclipse.persistence.internal.jaxb.DomHandlerConverter;
38	import org.eclipse.persistence.internal.jaxb.MultiArgInstantiationPolicy;	35	import org.eclipse.persistence.internal.jaxb.MultiArgInstantiationPolicy;
Lines 41-47 Link Here
41	import org.eclipse.persistence.mappings.AttributeAccessor;	38	import org.eclipse.persistence.mappings.AttributeAccessor;
42	import org.eclipse.persistence.mappings.DatabaseMapping;	39	import org.eclipse.persistence.mappings.DatabaseMapping;
43		40
44
45	import org.eclipse.persistence.oxm.*;	41	import org.eclipse.persistence.oxm.*;
46	import org.eclipse.persistence.oxm.mappings.*;	42	import org.eclipse.persistence.oxm.mappings.*;
47	import org.eclipse.persistence.oxm.mappings.converters.XMLRootConverter;	43	import org.eclipse.persistence.oxm.mappings.converters.XMLRootConverter;
Lines 272-278 Link Here
272	if (property.isSwaAttachmentRef() \|\| property.isMtomAttachment()) {	268	if (property.isSwaAttachmentRef() \|\| property.isMtomAttachment()) {
273	generateBinaryMapping(property, descriptor, namespaceInfo);	269	generateBinaryMapping(property, descriptor, namespaceInfo);
274	} else {	270	} else {
275	generateDirectMapping(property, descriptor, namespaceInfo);	271	if (referenceClass.getQualifiedName().equals("java.lang.Object")) {
		272	generateAnyObjectMapping(property, descriptor, namespaceInfo);
		273	} else {
		274	generateDirectMapping(property, descriptor, namespaceInfo);
		275	}
276	}	276	}
277	}	277	}
278	}	278	}
Lines 561-566 Link Here
561	descriptor.addMapping(mapping);	561	descriptor.addMapping(mapping);
562	}	562	}
563		563
		564	public void generateAnyObjectMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
		565	XMLAnyObjectMapping mapping = new XMLAnyObjectMapping();
		566	mapping.setAttributeName(property.getPropertyName());
		567	if (property.isMethodProperty()) {
		568	mapping.setGetMethodName(property.getGetMethodName());
		569	mapping.setSetMethodName(property.getSetMethodName());
		570	}
		571
		572	mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
		573
		574	descriptor.addMapping(mapping);
		575	}
		576
564	protected boolean areEquals(JavaClass src, Class tgt) {	577	protected boolean areEquals(JavaClass src, Class tgt) {
565	if (src == null \|\| tgt == null) {	578	if (src == null \|\| tgt == null) {
566	return false;	579	return false;