/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.cxf.binding.corba.types;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.namespace.QName;
import org.apache.cxf.binding.corba.CorbaBindingException;
import org.apache.cxf.binding.corba.CorbaTypeMap;
import org.apache.cxf.binding.corba.utils.CorbaUtils;
import org.apache.cxf.binding.corba.wsdl.Alias;
import org.apache.cxf.binding.corba.wsdl.Anonarray;
import org.apache.cxf.binding.corba.wsdl.Anonsequence;
import org.apache.cxf.binding.corba.wsdl.Array;
import org.apache.cxf.binding.corba.wsdl.CorbaTypeImpl;
import org.apache.cxf.binding.corba.wsdl.Exception;
import org.apache.cxf.binding.corba.wsdl.MemberType;
import org.apache.cxf.binding.corba.wsdl.Sequence;
import org.apache.cxf.binding.corba.wsdl.Struct;
import org.apache.cxf.binding.corba.wsdl.Union;
import org.apache.cxf.binding.corba.wsdl.Unionbranch;
import org.apache.cxf.binding.corba.wsdl.W3CConstants;
import org.apache.cxf.service.model.ServiceInfo;
import org.apache.ws.commons.schema.XmlSchemaComplexType;
import org.apache.ws.commons.schema.XmlSchemaElement;
import org.apache.ws.commons.schema.XmlSchemaObject;
import org.apache.ws.commons.schema.XmlSchemaParticle;
import org.apache.ws.commons.schema.XmlSchemaSequence;
import org.omg.CORBA.ORB;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCode;
public final class CorbaHandlerUtils {
private CorbaHandlerUtils() {
//utility class
}
public static CorbaObjectHandler createTypeHandler(ORB orb,
QName name,
QName idlType,
CorbaTypeMap typeMap) {
CorbaObjectHandler handler = null;
TypeCode tc = CorbaUtils.getTypeCode(orb, idlType, typeMap);
try {
while (tc.kind().value() == TCKind._tk_alias) {
Alias alias = (Alias) CorbaUtils.getCorbaType(idlType, typeMap);
if (alias == null) {
throw new CorbaBindingException("Couldn't find corba alias type: " + idlType);
}
tc = tc.content_type();
idlType = alias.getBasetype();
}
} catch (Throwable ex) {
throw new CorbaBindingException(ex);
}
if (CorbaUtils.isPrimitiveIdlType(idlType)) {
handler = new CorbaPrimitiveHandler(name, idlType, tc, null);
} else if (tc.kind().value() == TCKind._tk_any) {
// Any is a special kind of primitive so it gets its own handler
handler = new CorbaAnyHandler(name, idlType, tc, null);
((CorbaAnyHandler)handler).setTypeMap(typeMap);
} else {
CorbaTypeImpl type = CorbaUtils.getCorbaType(idlType, typeMap);
switch (tc.kind().value()) {
case TCKind._tk_array:
handler = new CorbaArrayHandler(name, idlType, tc, type);
break;
case TCKind._tk_enum:
handler = new CorbaEnumHandler(name, idlType, tc, type);
break;
case TCKind._tk_except:
handler = new CorbaExceptionHandler(name, idlType, tc, type);
break;
case TCKind._tk_fixed:
handler = new CorbaFixedHandler(name, idlType, tc, type);
break;
case TCKind._tk_sequence:
if (isOctets(type)) {
handler = new CorbaOctetSequenceHandler(name, idlType, tc, type);
} else {
handler = new CorbaSequenceHandler(name, idlType, tc, type);
}
break;
case TCKind._tk_struct:
handler = new CorbaStructHandler(name, idlType, tc, type);
break;
case TCKind._tk_union:
handler = new CorbaUnionHandler(name, idlType, tc, type);
break;
case TCKind._tk_string:
case TCKind._tk_wstring:
// These need to be here to catch the anonymous string types.
handler = new CorbaPrimitiveHandler(name, idlType, tc, type);
break;
case TCKind._tk_objref:
handler = new CorbaObjectReferenceHandler(name, idlType, tc, type);
break;
default:
handler = new CorbaObjectHandler(name, idlType, tc, type);
}
}
return handler;
}
public static CorbaObjectHandler initializeObjectHandler(ORB orb,
QName name,
QName idlType,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo) {
Map<QName, CorbaObjectHandler> seenTypes = new HashMap<QName, CorbaObjectHandler>();
return initializeObjectHandler(orb, name, idlType, typeMap, serviceInfo, seenTypes);
}
public static CorbaObjectHandler initializeObjectHandler(ORB orb,
QName name,
QName idlType,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
CorbaObjectHandler obj = createTypeHandler(orb, name, idlType, typeMap);
if (!CorbaUtils.isPrimitiveIdlType(idlType)) {
switch (obj.getTypeCode().kind().value()) {
case TCKind._tk_any:
((CorbaAnyHandler)obj).setValue(orb.create_any());
break;
case TCKind._tk_array:
initializeArrayHandler(orb, obj, typeMap, serviceInfo, seenTypes);
break;
case TCKind._tk_except:
initializeExceptionHandler(orb, obj, typeMap, serviceInfo, seenTypes);
break;
case TCKind._tk_sequence:
if (!isOctets(obj.getType())) {
initializeSequenceHandler(orb, obj, typeMap, serviceInfo, seenTypes);
}
break;
case TCKind._tk_struct:
initializeStructHandler(orb, obj, typeMap, serviceInfo, seenTypes);
break;
case TCKind._tk_union:
initializeUnionHandler(orb, obj, typeMap, serviceInfo, seenTypes);
break;
default:
// TODO: Should we raise an exception or log?
}
}
return obj;
}
public static void initializeArrayHandler(ORB orb,
CorbaObjectHandler obj,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
QName arrayElementType = null;
long arrayBound = 0;
CorbaTypeImpl baseType = obj.getType();
QName elementName;
if (baseType instanceof Array) {
Array arrayType = (Array)baseType;
arrayElementType = arrayType.getElemtype();
arrayBound = arrayType.getBound();
elementName = arrayType.getElemname();
} else {
Anonarray anonArrayType = (Anonarray)baseType;
arrayElementType = anonArrayType.getElemtype();
arrayBound = anonArrayType.getBound();
elementName = anonArrayType.getElemname();
}
for (int i = 0; i < arrayBound; ++i) {
CorbaObjectHandler elementObj =
initializeObjectHandler(orb, elementName, arrayElementType, typeMap, serviceInfo,
seenTypes);
((CorbaArrayHandler)obj).addElement(elementObj);
}
}
public static void initializeExceptionHandler(ORB orb,
CorbaObjectHandler obj,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
Exception exceptType = (Exception)obj.getType();
List<MemberType> exceptMembers = exceptType.getMember();
QName typeName = exceptType.getType();
for (int i = 0; i < exceptMembers.size(); ++i) {
MemberType member = exceptMembers.get(i);
QName memberName;
if (member.isSetQualified() && member.isQualified() && (typeName != null)) {
memberName = new QName(typeName.getNamespaceURI(), member.getName());
} else {
memberName = new QName("", member.getName());
}
QName memberType = member.getIdltype();
CorbaObjectHandler memberObj = initializeObjectHandler(orb,
memberName,
memberType,
typeMap,
serviceInfo,
seenTypes);
((CorbaExceptionHandler)obj).addMember(memberObj);
}
}
public static void initializeSequenceHandler(ORB orb,
CorbaObjectHandler obj,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
QName seqElementType = null;
long seqBound = 0;
CorbaTypeImpl baseType = obj.getType();
QName elementName;
if (baseType instanceof Sequence) {
Sequence seqType = (Sequence)baseType;
seqElementType = seqType.getElemtype();
seqBound = seqType.getBound();
elementName = seqType.getElemname();
} else {
Anonsequence seqType = (Anonsequence)baseType;
seqElementType = seqType.getElemtype();
seqBound = seqType.getBound();
elementName = seqType.getElemname();
}
if (seqBound == 0) {
// This is an unbounded sequence. Store a 'template' object that we can use to create
// new objects as needed
CorbaObjectHandler elementObj = null;
// Check for a recursive type
if (seenTypes.get(seqElementType) != null) {
elementObj = seenTypes.get(seqElementType);
elementObj.setRecursive(true);
((CorbaSequenceHandler)obj).hasRecursiveTypeElement(true);
} else {
elementObj =
initializeObjectHandler(orb, elementName, seqElementType, typeMap,
serviceInfo, seenTypes);
}
((CorbaSequenceHandler)obj).setTemplateElement(elementObj);
}
for (int i = 0; i < seqBound; ++i) {
CorbaObjectHandler elementObj = null;
// Check for a recursive type
if (seenTypes.get(seqElementType) != null) {
// Even though this is bounded, if we have a recursive type, we'll still use the
// template object so that we don't overwrite the value of the element.
elementObj = seenTypes.get(seqElementType);
elementObj.setRecursive(true);
((CorbaSequenceHandler)obj).hasRecursiveTypeElement(true);
((CorbaSequenceHandler)obj).setTemplateElement(elementObj);
} else {
elementObj =
initializeObjectHandler(orb, elementName, seqElementType, typeMap, serviceInfo,
seenTypes);
((CorbaSequenceHandler)obj).addElement(elementObj);
}
}
}
public static void initializeStructHandler(ORB orb,
CorbaObjectHandler obj,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
Struct structType = (Struct)obj.getType();
List<MemberType> structMembers = structType.getMember();
QName typeName = structType.getType();
seenTypes.put(obj.getIdlType(), obj);
for (int i = 0; i < structMembers.size(); ++i) {
MemberType member = structMembers.get(i);
QName memberName;
if (member.isSetQualified() && member.isQualified() && (typeName != null)) {
memberName = new QName(typeName.getNamespaceURI(), member.getName());
} else {
memberName = new QName("", member.getName());
}
QName memberType = member.getIdltype();
CorbaObjectHandler memberObj = initializeObjectHandler(orb,
memberName,
memberType,
typeMap,
serviceInfo,
seenTypes);
if (member.isSetAnonschematype() && member.isAnonschematype()) {
memberObj.setAnonymousType(true);
}
((CorbaStructHandler)obj).addMember(memberObj);
}
seenTypes.remove(obj.getIdlType());
}
public static void initializeUnionHandler(ORB orb,
CorbaObjectHandler obj,
CorbaTypeMap typeMap,
ServiceInfo serviceInfo,
Map<QName, CorbaObjectHandler> seenTypes) {
Union unionType = (Union)obj.getType();
// First handle the discriminator
CorbaObjectHandler discObj = initializeObjectHandler(orb,
new QName("discriminator"),
unionType.getDiscriminator(),
typeMap,
serviceInfo,
seenTypes);
((CorbaUnionHandler)obj).setDiscriminator(discObj);
QName typeName = unionType.getType();
seenTypes.put(obj.getIdlType(), obj);
// Now handle all of the branches
List<Unionbranch> unionBranches = unionType.getUnionbranch();
for (int i = 0; i < unionBranches.size(); i++) {
Unionbranch branch = unionBranches.get(i);
QName branchName;
if (branch.isSetQualified() && branch.isQualified() && (typeName != null)) {
branchName = new QName(typeName.getNamespaceURI(), branch.getName());
} else {
branchName = new QName("", branch.getName());
}
QName branchIdlType = branch.getIdltype();
CorbaObjectHandler branchObj =
initializeObjectHandler(orb, branchName, branchIdlType, typeMap, serviceInfo,
seenTypes);
((CorbaUnionHandler)obj).addCase(branchObj);
}
seenTypes.remove(obj.getIdlType());
}
//Change this method to access the XmlSchemaCollection.
public static String getNamespaceURI(ServiceInfo serviceInfo, QName typeName) {
String nsUri = "";
if ((typeName != null)
&& (CorbaUtils.isElementFormQualified(serviceInfo, typeName.getNamespaceURI()))) {
nsUri = typeName.getNamespaceURI();
}
return nsUri;
}
public static XmlSchemaElement getXmlSchemaSequenceElement(XmlSchemaObject schemaType,
ServiceInfo serviceInfo) {
XmlSchemaObject stype = schemaType;
XmlSchemaElement el = null;
if (schemaType instanceof XmlSchemaElement) {
stype = ((XmlSchemaElement) schemaType).getSchemaType();
if (stype == null) {
stype = CorbaUtils.getXmlSchemaType(serviceInfo,
((XmlSchemaElement) schemaType)
.getRef().getTargetQName());
}
}
if (stype instanceof XmlSchemaComplexType) {
//only one element inside the XmlSchemaComplexType
XmlSchemaComplexType ctype = (XmlSchemaComplexType) stype;
XmlSchemaParticle group = ctype.getParticle();
/* This code seems to think that we're guaranteed a sequence here */
XmlSchemaSequence seq = (XmlSchemaSequence) group;
/* and an element in it, too */
el = (XmlSchemaElement) seq.getItems().get(0);
} else {
el = (XmlSchemaElement) schemaType;
}
return el;
}
public static CorbaTypeListener getTypeListener(QName name,
QName idlType,
CorbaTypeMap typeMap,
ORB orb, ServiceInfo serviceInfo)
throws CorbaBindingException {
CorbaObjectHandler handler = null;
TypeCode tc = CorbaUtils.getTypeCode(orb, idlType, typeMap);
try {
while (tc.kind().value() == TCKind._tk_alias) {
Alias alias = (Alias) CorbaUtils.getCorbaType(idlType, typeMap);
if (alias == null) {
throw new CorbaBindingException("Couldn't find corba alias type: " + idlType);
}
tc = tc.content_type();
idlType = alias.getBasetype();
}
} catch (Throwable ex) {
throw new CorbaBindingException(ex);
}
CorbaTypeListener result = null;
if (CorbaUtils.isPrimitiveIdlType(idlType)) {
handler = new CorbaPrimitiveHandler(name, idlType, tc, null);
result = new CorbaPrimitiveListener(handler);
} else {
CorbaTypeImpl type = CorbaUtils.getCorbaType(idlType, typeMap);
switch (tc.kind().value()) {
case TCKind._tk_any:
handler = new CorbaAnyHandler(name, idlType, tc, type);
((CorbaAnyHandler)handler).setTypeMap(typeMap);
result = new CorbaAnyListener(handler, typeMap, orb, serviceInfo);
break;
case TCKind._tk_array:
handler = new CorbaArrayHandler(name, idlType, tc, type);
result = new CorbaArrayListener(handler, typeMap, orb, serviceInfo);
break;
case TCKind._tk_enum:
handler = new CorbaEnumHandler(name, idlType, tc, type);
result = new CorbaEnumListener(handler);
break;
case TCKind._tk_except:
handler = new CorbaExceptionHandler(name, idlType, tc, type);
result = new CorbaExceptionListener(handler, typeMap, orb, serviceInfo);
break;
case TCKind._tk_fixed:
handler = new CorbaFixedHandler(name, idlType, tc, type);
result = new CorbaFixedListener(handler);
break;
case TCKind._tk_sequence:
if (isOctets(type)) {
handler = new CorbaOctetSequenceHandler(name, idlType, tc, type);
result = new CorbaOctetSequenceListener(handler);
} else {
handler = new CorbaSequenceHandler(name, idlType, tc, type);
result = new CorbaSequenceListener(handler, typeMap, orb, serviceInfo);
}
break;
case TCKind._tk_string:
case TCKind._tk_wstring:
// These can be handled just like regular strings
handler = new CorbaPrimitiveHandler(name, idlType, tc, type);
result = new CorbaPrimitiveListener(handler);
break;
case TCKind._tk_struct:
handler = new CorbaStructHandler(name, idlType, tc, type);
result = new CorbaStructListener(handler, typeMap, orb, serviceInfo);
break;
case TCKind._tk_union:
handler = new CorbaUnionHandler(name, idlType, tc, type);
result = new CorbaUnionListener(handler, typeMap, orb, serviceInfo);
break;
case TCKind._tk_objref:
handler =
new CorbaObjectReferenceHandler(name, idlType, tc, type);
result = new CorbaObjectReferenceListener(handler, orb);
break;
default:
throw new CorbaBindingException("Unsupported complex type " + idlType);
}
}
return result;
}
public static CorbaTypeEventProducer getTypeEventProducer(CorbaObjectHandler handler,
ServiceInfo serviceInfo,
ORB orb)
throws CorbaBindingException {
QName idlType = handler.getIdlType();
TypeCode tc = handler.getTypeCode();
CorbaTypeEventProducer result = null;
if (CorbaUtils.isPrimitiveIdlType(idlType)) {
result = new CorbaPrimitiveTypeEventProducer(handler);
} else {
switch (tc.kind().value()) {
case TCKind._tk_any:
result = new CorbaAnyEventProducer(handler, serviceInfo, orb);
break;
case TCKind._tk_array:
result = new CorbaArrayEventProducer(handler, serviceInfo, orb);
break;
case TCKind._tk_enum:
result = new CorbaEnumEventProducer(handler);
break;
case TCKind._tk_except:
result = new CorbaExceptionEventProducer(handler, serviceInfo, orb);
break;
case TCKind._tk_fixed:
result = new CorbaFixedEventProducer(handler);
break;
case TCKind._tk_sequence:
if (isOctets(handler.getType())) {
result = new CorbaOctetSequenceEventProducer(handler);
} else {
result = new CorbaSequenceEventProducer(handler, serviceInfo, orb);
}
break;
case TCKind._tk_string:
case TCKind._tk_wstring:
// These can be handled just like regular strings
result = new CorbaPrimitiveTypeEventProducer(handler);
break;
case TCKind._tk_struct:
if (handler.isAnonymousType()) {
result = new CorbaAnonStructEventProducer(handler, serviceInfo, orb);
} else {
result = new CorbaStructEventProducer(handler, serviceInfo, orb);
}
break;
case TCKind._tk_union:
result = new CorbaUnionEventProducer(handler, serviceInfo, orb);
break;
case TCKind._tk_objref:
result = new CorbaObjectReferenceEventProducer(handler, serviceInfo, orb);
break;
default:
throw new CorbaBindingException("Unsupported complex type "
+ idlType);
}
}
return result;
}
public static boolean isPrimitiveIDLTypeSequence(CorbaObjectHandler handler) {
CorbaTypeImpl seqType = handler.getType();
QName seqElementType;
if (seqType instanceof Anonsequence) {
Anonsequence anonSeqType = (Anonsequence) seqType;
seqElementType = anonSeqType.getElemtype();
} else {
Sequence type = (Sequence) seqType;
seqElementType = type.getElemtype();
}
return CorbaUtils.isPrimitiveIdlType(seqElementType);
}
public static boolean isAnonType(XmlSchemaObject schemaObj) {
boolean result = false;
if ((schemaObj != null) && !(schemaObj instanceof XmlSchemaElement)
&& !(schemaObj instanceof XmlSchemaComplexType)) {
result = true;
}
return result;
}
public static boolean isOctets(CorbaTypeImpl baseType) {
return baseType.getType().equals(W3CConstants.NT_SCHEMA_BASE64)
|| baseType.getType().equals(W3CConstants.NT_SCHEMA_HBIN);
}
}