in modules/jibx-codegen/src/main/java/org/apache/axis2/jibx/CodeGenerationUtility.java [690:976]
private Element unwrapMessage(AxisMessage msg, boolean isout,
Map simpleTypeMap, Map elementMap, Map complexTypeMap, Map typeMappedClassMap,
Map bindingMap, Set nameset, Map nsmap, Document doc) {
// find the schema definition for this message element
QName qname = msg.getElementQName();
if (qname == null) {
throw new RuntimeException("No element reference in message " + msg.getName());
}
XmlSchemaElement wrapdef = codeGenConfig.getAxisService().getSchemaElement(qname);
if (wrapdef == null) {
throw new RuntimeException("Cannot unwrap - no definition found for element " + qname);
}
XmlSchemaType type = wrapdef.getSchemaType();
// create document to hold data binding details for element
Element wrapdetail = doc.createElement(isout ? "out-wrapper" : "in-wrapper");
wrapdetail.setAttribute("ns", qname.getNamespaceURI());
wrapdetail.setAttribute("name", qname.getLocalPart());
// dig down to the complexType particle
List partNameList = new ArrayList();
String wrappertype = "";
boolean nons = qname.getNamespaceURI().length() == 0;
boolean dfltns = false;
boolean complex = false;
if (type instanceof XmlSchemaComplexType) {
XmlSchemaComplexType ctype = (XmlSchemaComplexType)type;
if (!ctype.getAttributes().isEmpty()) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": attributes not allowed on type to be unwrapped");
}
XmlSchemaParticle particle = ctype.getParticle();
if (particle != null) {
// if there's a particle present, it must be a sequence
if (!(particle instanceof XmlSchemaSequence)) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": type to be unwrapped must be a sequence");
}
if (particle.getMinOccurs() != 1 || particle.getMaxOccurs() != 1) {
throw new RuntimeException("Cannot unwrap element " +
qname +
": contained sequence must have minOccurs='1' and maxOccurs='1'");
}
XmlSchemaSequence sequence = (XmlSchemaSequence)particle;
// add child param element matching each child of wrapper element
QName opName = msg.getAxisOperation().getName();
boolean first = true;
for (XmlSchemaSequenceMember member : sequence.getItems()) {
// check that child item obeys the unwrapping rules
XmlSchemaParticle item = (XmlSchemaParticle)member;
if (!(item instanceof XmlSchemaElement)) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": only element items allowed in sequence");
}
XmlSchemaElement element = (XmlSchemaElement)item;
QName refname = element.getRef().getTargetQName();
QName typename = element.getSchemaTypeName();
if (refname == null && typename == null) {
throw new RuntimeException("Cannot unwrap element " +
qname +
": all elements in contained sequence must be element references or reference a named type");
}
if (first) {
first = false;
} else if (isout) {
throw new RuntimeException("Cannot unwrap element " +
qname +
": only one child element allowed in sequence for wrapped output");
}
// add element to output with details of this element handling
Element param =
doc.createElement(isout ? "return-element" : "parameter-element");
QName itemname = (refname == null) ? element.getQName() : refname;
nons = nons || itemname.getNamespaceURI().length() == 0;
param.setAttribute("ns", itemname.getNamespaceURI());
param.setAttribute("name", itemname.getLocalPart());
String javaname = toJavaName(itemname.getLocalPart(), nameset);
param.setAttribute("java-name", javaname);
param.setAttribute("nillable", Boolean.toString(element.isNillable()));
boolean optional = element.getMinOccurs() == 0;
param.setAttribute("optional", Boolean.toString(optional));
boolean isarray = element.getMaxOccurs() > 1;
param.setAttribute("array", Boolean.toString(isarray));
String javatype;
String createtype = null;
if (element.getSchemaType() instanceof XmlSchemaSimpleType) {
// simple type translates to format element in binding
FormatElement format = (FormatElement)simpleTypeMap.get(typename);
if (format == null) {
// check for restriction with simple base, and treat as base if so
XmlSchemaSimpleType stype = (XmlSchemaSimpleType)element.getSchemaType();
XmlSchemaSimpleTypeContent content = stype.getContent();
if (content instanceof XmlSchemaSimpleTypeRestriction) {
QName tname = ((XmlSchemaSimpleTypeRestriction)content).getBaseTypeName();
if (SCHEMA_NAMESPACE.equals(tname.getNamespaceURI())) {
format = (FormatElement)simpleTypeMap.get(tname);
if (format != null) {
typename = tname;
}
}
}
}
if (format == null) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": no format definition found for type " +
typename + " (used by element " + itemname + ')');
}
javatype = format.getTypeName();
param.setAttribute("form", "simple");
param.setAttribute("serializer", format.getSerializerName());
param.setAttribute("deserializer", format.getDeserializerName());
// convert primitive types to wrapper types for nillable
if ((optional || element.isNillable()) &&
s_wrapperMap.containsKey(javatype)) {
param.setAttribute("wrapped-primitive", "true");
param.setAttribute("value-method", javatype + "Value");
javatype = (String)s_wrapperMap.get(javatype);
} else {
param.setAttribute("wrapped-primitive", "false");
String dflt = element.getDefaultValue();
if (dflt == null) {
dflt = format.getDefaultText();
if (javatype.equals("float")) {
dflt = dflt + 'F';
}
}
if (dflt != null) {
param.setAttribute("default", dflt);
}
}
} else {
// conversion must be defined by mapping
MappingElementBase mapping;
if (refname == null) {
// complex type reference translates to abstract mapping in binding
mapping = (MappingElementBase)complexTypeMap.get(typename);
if (mapping == null) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": no abstract mapping definition found for type " +
typename + " (used by element " + itemname + ')');
}
Integer tindex = (Integer)typeMappedClassMap.get(typename);
if (tindex == null) {
tindex = new Integer(typeMappedClassMap.size());
typeMappedClassMap.put(typename, tindex);
}
param.setAttribute("type-index", tindex.toString());
} else {
// element reference translates to concrete mapping
mapping = (MappingElementBase)elementMap.get(refname);
if (mapping == null) {
throw new RuntimeException("Cannot unwrap element " +
qname + ": no concrete mapping definition found for element " +
refname + " (used by element " + itemname + ')');
}
param.setAttribute("type-index", "");
}
// configure based on the mapping information
param.setAttribute("form", "complex");
complex = true;
javatype = mapping.getClassName();
createtype = mapping.getCreateType();
if (createtype == null && mapping.isAbstract() &&
mapping.getExtensionTypes().isEmpty()) {
// abstract mapping with no extensions requires instance
// this assumes the mapped type can be created, but no easy way to check
createtype = javatype;
}
// merge contained namespace definitions into set for operation
Iterator citer = mapping.topChildIterator();
while (citer.hasNext()) {
ElementBase child = (ElementBase)citer.next();
if (child.type() == ElementBase.NAMESPACE_ELEMENT) {
dfltns = mapNamespace((NamespaceElement)child, dfltns, nsmap);
} else {
break;
}
}
// also merge namespace definitions from binding
BindingElement binding = (BindingElement)bindingMap.get(mapping);
citer = binding.topChildIterator();
while (citer.hasNext()) {
ElementBase child = (ElementBase)citer.next();
if (child.type() == ElementBase.NAMESPACE_ELEMENT) {
dfltns = mapNamespace((NamespaceElement)child, dfltns, nsmap);
} else if (child.type() != ElementBase.INCLUDE_ELEMENT) {
break;
}
}
}
param.setAttribute("java-type", javatype);
if (createtype != null) {
param.setAttribute("create-type", createtype);
}
boolean isobj = !s_primitiveSet.contains(javatype);
String fulltype = javatype;
if (isarray) {
fulltype += "[]";
isobj = false;
}
param.setAttribute("object", Boolean.toString(isobj));
if (isout) {
wrappertype = fulltype;
} else {
wrappertype = "java.lang.Object";
}
wrapdetail.appendChild(param);
// this magic code comes from org.apache.axis2.wsdl.codegen.extension.SchemaUnwrapperExtension
// it's used here to fit into the ADB-based code generation model
QName partqname = WSDLUtil.getPartQName(opName.getLocalPart(),
WSDLConstants.INPUT_PART_QNAME_SUFFIX,
javaname);
partNameList.add(partqname);
// add type mapping so we look like ADB
codeGenConfig.getTypeMapper().addTypeMappingName(partqname, fulltype);
}
// check namespace prefix usage
if (nons && dfltns) {
throw new RuntimeException("Cannot unwrap element " + qname +
": no-namespace element(s) conflict with default namespace use in binding");
}
wrapdetail.setAttribute("uses-default", Boolean.toString(nons));
// set flag for namespace declarations needed on wrapper
wrapdetail.setAttribute("need-namespaces", Boolean.toString(complex));
}
} else if (type != null) {
throw new RuntimeException("Cannot unwrap element " + qname +
": not a complexType definition");
}
if (wrapdetail.getFirstChild() == null) {
wrapdetail.setAttribute("empty", "true");
wrapdetail.setAttribute("need-namespaces", "false");
wrappertype = "";
} else {
wrapdetail.setAttribute("empty", "false");
}
// this magic code comes from org.apache.axis2.wsdl.codegen.extension.SchemaUnwrapperExtension
// it's used here to fit into the ADB-based code generation model
MessagePartInformationHolder infoHolder = new MessagePartInformationHolder();
infoHolder.setOperationName(msg.getAxisOperation().getName());
infoHolder.setPartsList(partNameList);
try {
msg.addParameter(new Parameter(Constants.UNWRAPPED_DETAILS, infoHolder));
} catch (AxisFault e) {
throw new RuntimeException(e);
}
// set indication for unwrapped message
try {
msg.addParameter(new Parameter(Constants.UNWRAPPED_KEY, Boolean.TRUE));
} catch (AxisFault e) {
throw new RuntimeException(e);
}
// add fake mapping for wrapper name (necessary for current XSLTs)
codeGenConfig.getTypeMapper().addTypeMappingName(qname, wrappertype);
// return the unwrapping details
return wrapdetail;
}