/*
* 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.axis2.corba.receivers;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMNamespace;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.corba.deployer.CorbaConstants;
import org.apache.axis2.corba.exceptions.CorbaException;
import org.apache.axis2.corba.exceptions.CorbaInvocationException;
import org.apache.axis2.corba.idl.IDLProcessor;
import org.apache.axis2.corba.idl.types.AbstractCollectionType;
import org.apache.axis2.corba.idl.types.ArrayType;
import org.apache.axis2.corba.idl.types.CompositeDataType;
import org.apache.axis2.corba.idl.types.DataType;
import org.apache.axis2.corba.idl.types.EnumType;
import org.apache.axis2.corba.idl.types.ExceptionType;
import org.apache.axis2.corba.idl.types.IDL;
import org.apache.axis2.corba.idl.types.Member;
import org.apache.axis2.corba.idl.types.PrimitiveDataType;
import org.apache.axis2.corba.idl.types.SequenceType;
import org.apache.axis2.corba.idl.types.Struct;
import org.apache.axis2.corba.idl.types.Typedef;
import org.apache.axis2.corba.idl.types.UnionMember;
import org.apache.axis2.corba.idl.types.UnionType;
import org.apache.axis2.corba.idl.types.ValueType;
import org.apache.axis2.corba.idl.values.AbstractCollectionValue;
import org.apache.axis2.corba.idl.values.AbstractValue;
import org.apache.axis2.corba.idl.values.AliasValue;
import org.apache.axis2.corba.idl.values.ArrayValue;
import org.apache.axis2.corba.idl.values.EnumValue;
import org.apache.axis2.corba.idl.values.ExceptionValue;
import org.apache.axis2.corba.idl.values.ObjectByValue;
import org.apache.axis2.corba.idl.values.SequenceValue;
import org.apache.axis2.corba.idl.values.StreamableValueFactory;
import org.apache.axis2.corba.idl.values.StructValue;
import org.apache.axis2.corba.idl.values.UnionValue;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.java2wsdl.TypeTable;
import org.apache.axis2.namespace.Constants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.omg.CORBA.Any;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA_2_3.ORB;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
import org.omg.CosNaming.NamingContextPackage.InvalidName;
import org.omg.CosNaming.NamingContextPackage.NotFound;
import javax.xml.namespace.QName;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public class CorbaUtil implements CorbaConstants {
private static Map IDL_CACHE = new HashMap();
private static final Log log = LogFactory.getLog(CorbaUtil.class);
public static org.omg.CORBA_2_3.ORB getORB(AxisService service) {
Parameter orbClass = service.getParameter(ORB_CLASS);
Parameter orbSingletonClass = service.getParameter(ORB_SINGLETON_CLASS);
Properties props = System.getProperties();
if (orbClass!=null)
props.put(ORG_OMG_CORBA_ORBCLASS, orbClass.getValue());
else
props.put(ORG_OMG_CORBA_ORBCLASS, DEFAULR_ORB_CLASS);
if (orbSingletonClass!=null)
props.put(ORG_OMG_CORBA_ORBSINGLETON_CLASS, orbSingletonClass.getValue());
else
props.put(ORG_OMG_CORBA_ORBSINGLETON_CLASS, DEFAULT_ORBSINGLETON_CLASS);
return (ORB) ORB.init(new String[]{}, props);
}
public static org.omg.CORBA.Object resolveObject(AxisService service, org.omg.CORBA_2_3.ORB orb) throws CorbaInvocationException {
org.omg.CORBA.Object obj;
try {
Parameter namingServiceUrl = service.getParameter(NAMING_SERVICE_URL);
Parameter objectName = service.getParameter(OBJECT_NAME);
Parameter iorFilePath = service.getParameter(IOR_FILE_PATH);
Parameter iorString = service.getParameter(IOR_STRING);
if (namingServiceUrl!=null && objectName!=null) {
obj = orb.string_to_object((String) namingServiceUrl.getValue());
NamingContextExt nc = NamingContextExtHelper.narrow(obj);
obj = nc.resolve(nc.to_name((String) objectName.getValue()));
} else if (iorFilePath!=null) {
FileReader fileReader = new FileReader((String) iorFilePath.getValue());
char[] buf = new char[1000];
fileReader.read(buf);
obj = orb.string_to_object((new String(buf)).trim());
} else if (iorString!=null) {
obj = orb.string_to_object((String) iorString.getValue());
} else {
throw new CorbaInvocationException("cannot resolve object");
}
} catch (NotFound notFound) {
throw new CorbaInvocationException("cannot resolve object", notFound);
} catch (CannotProceed cannotProceed) {
throw new CorbaInvocationException("cannot resolve object", cannotProceed);
} catch (InvalidName invalidName) {
throw new CorbaInvocationException("cannot resolve object", invalidName);
} catch (IOException e) {
throw new CorbaInvocationException("cannot resolve object", e);
}
return obj;
}
public static IDL getIDL(AxisService service, ORB orb, String dirName) throws CorbaException {
Parameter idlFile = service.getParameter(IDL_FILE);
String idlFileName = (String) idlFile.getValue();
String cacheKey = dirName + File.separator + idlFileName;
IDL idl = (IDL) IDL_CACHE.get(cacheKey);
if (idl==null) {
try {
File file = new File(dirName);
InputStream stream;
if (file.isDirectory()) {
stream = new FileInputStream(cacheKey);
} else {
ZipInputStream zin = new ZipInputStream(new FileInputStream(file));
ZipEntry entry;
boolean found = false;
while ((entry = zin.getNextEntry()) != null) {
if (entry.getName().equalsIgnoreCase(idlFileName)) {
found = true;
break;
}
}
if (!found)
new CorbaInvocationException("cannot find " + idlFileName + " in " + file.getPath());
stream = zin;
}
IDLProcessor idlProcessor = new IDLProcessor(stream);
idl = idlProcessor.process();
stream.close();
IDL_CACHE.put(cacheKey, idl);
} catch (IOException e) {
throw new CorbaInvocationException("cannot process idl file", e);
}
}
Map types = idl.getCompositeDataTypes();
if (types!=null) {
Iterator iter = types.values().iterator();
while (iter.hasNext()) {
DataType type = (DataType) iter.next();
if (type instanceof ValueType) {
StreamableValueFactory.register(orb, (ValueType) type);
}
}
}
return idl;
}
public static Invoker getInvoker(AxisService service, org.omg.CORBA.Object obj, IDL idl, String methodName) throws CorbaInvocationException {
InvokerFactory invokerFactory = new CorbaInvokerFactory(idl);
Parameter interfaceName = service.getParameter(INTERFACE_NAME);
if (interfaceName==null)
throw new CorbaInvocationException("interfaceName cannot be null");
return invokerFactory.newInvoker((String) interfaceName.getValue(), methodName, obj);
}
public static Object[] extractParameters(OMElement methodElement, Member[] parameterMembers) throws CorbaInvocationException {
if (parameterMembers==null)
return new Object[0];
Object[] retObjs = new Object[parameterMembers.length];
if (methodElement==null)
return retObjs;
Iterator paramsIter = methodElement.getChildElements();
Map paramsMap = new HashMap();
String localName;
while(paramsIter!=null && paramsIter.hasNext()) {
OMElement param = (OMElement) paramsIter.next();
localName = param.getLocalName();
if (paramsMap.containsKey(localName)) {
Object value = paramsMap.get(localName);
if (value instanceof List) {
((List) value).add(param);
} else {
List valueList = new ArrayList();
valueList.add(value);
valueList.add(param);
paramsMap.put(localName, valueList);
}
} else {
paramsMap.put(localName, param);
}
}
String paramName;
for (int i = 0; i < parameterMembers.length; i++) {
paramName = parameterMembers[i].getName();
retObjs[i] = extractValue(parameterMembers[i].getDataType(), paramsMap.get(paramName));
}
return retObjs;
}
private static Object extractValue(DataType dataType, Object param) throws CorbaInvocationException {
if (dataType instanceof Typedef) {
Typedef typedef = (Typedef) dataType;
AliasValue aliasValue = new AliasValue(typedef);
OMElement paramElement;
if (param instanceof OMElement)
paramElement = (OMElement) param;
else
return null;
DataType aliasType = typedef.getDataType();
if (!(aliasType instanceof AbstractCollectionType)) {
paramElement = paramElement.getFirstElement();
if (paramElement == null || !ARRAY_ITEM.equals(paramElement.getLocalName()))
return null;
}
aliasValue.setValue(extractValue(aliasType, paramElement));
return aliasValue;
} else if (dataType instanceof PrimitiveDataType) {
if (param!=null)
return parseValue(dataType, ((OMElement) param).getText());
} else if (dataType instanceof AbstractCollectionType) {
AbstractCollectionType collectionType = (AbstractCollectionType) dataType;
OMElement paramElement;
if (param instanceof OMElement)
paramElement = (OMElement) param;
else
return null;
Iterator paramsIter = paramElement.getChildElements();
List children = new ArrayList();
while (paramsIter.hasNext()) {
children.add(extractValue(collectionType.getDataType(), paramsIter.next()));
}
AbstractCollectionValue collectionValue;
if (collectionType.isArray()) {
collectionValue = new ArrayValue((ArrayType) collectionType);
} else if (collectionType.isSequence()) {
collectionValue = new SequenceValue((SequenceType) collectionType);
} else {
return null;
}
collectionValue.setValues(children.toArray());
return collectionValue;
} else if (dataType instanceof EnumType) {
EnumType enumType = (EnumType) dataType;
String enumText = ((OMElement) param).getText();
int index = enumType.getEnumMembers().indexOf(enumText);
if (index >= 0) {
EnumValue enumValue = new EnumValue(enumType);
enumValue.setValue(index);
return enumValue;
}
} else if (dataType instanceof UnionType) {
UnionType unionType = (UnionType) dataType;
OMElement unElement = ((OMElement) param).getFirstElement();
String unionMemberName = unElement.getLocalName();
UnionValue unionValue = new UnionValue(unionType);
unionValue.setMemberName(unionMemberName);
Member[] members = unionType.getMembers();
UnionMember member = null;
for (int i = 0; i < members.length; i++) {
member = (UnionMember) members[i];
if (member.getName().equals(unionMemberName)) {
break;
}
}
if (member != null) {
unionValue.setMemberValue(extractValue(member.getDataType(), unElement));
}
return unionValue;
} else if (dataType instanceof CompositeDataType) {
CompositeDataType compositeType = (CompositeDataType) dataType;
Member[] compositeMembers = compositeType.getMembers();
Object[] compositeValues = extractParameters(((OMElement) param), compositeMembers);
AbstractValue value;
if (compositeType instanceof ValueType)
value = new ObjectByValue((ValueType) compositeType);
else if (compositeType instanceof Struct)
value = new StructValue((Struct) compositeType);
else
throw new CorbaInvocationException("Parameter type not supported");
value.setMemberValues(compositeValues);
return value;
}
return null;
}
public static void processResponse(Object resObject,
Member[] params,
Object[] outParamValues,
DataType dataType,
AxisService service,
String methodName,
SOAPFactory fac,
String messageNameSpace,
MessageContext outMessage) throws AxisFault {
boolean qualified = service.isElementFormDefault();
OMNamespace ns = fac.createOMNamespace(messageNameSpace, service.getSchemaTargetNamespacePrefix());
OMElement bodyContent = fac.createOMElement(methodName + RESPONSE, ns);
OMElement child;
if (qualified) {
child = fac.createOMElement(RETURN_WRAPPER, ns);
} else {
child = fac.createOMElement(RETURN_WRAPPER, null);
}
bodyContent.addChild(child);
if (dataType!=null
&& !getQualifiedName(dataType).equals(VOID)
&& resObject!=null) {
processResponse(child, bodyContent, resObject, dataType, fac, ns, qualified, service);
} else {
child.addAttribute("nil", "true", fac.createOMNamespace(Constants.URI_2001_SCHEMA_XSI,
Constants.NS_PREFIX_SCHEMA_XSI));
}
Member param;
List outParamList = Arrays.asList(outParamValues);
Iterator paramsIter = outParamList.iterator();
for (int i = 0; i < params.length; i++) {
param = params[i];
if (Member.MODE_INOUT.equals(param.getMode())
|| Member.MODE_OUT.equals(param.getMode())) {
if (qualified) {
child = fac.createOMElement(param.getName(), ns);
} else {
child = fac.createOMElement(param.getName(), null);
}
bodyContent.addChild(child);
processResponse(child, bodyContent, paramsIter.next(), param.getDataType(), fac, ns, qualified, service);
}
}
SOAPEnvelope envelope = fac.getDefaultEnvelope();
envelope.getBody().addChild(bodyContent);
outMessage.setEnvelope(envelope);
}
private static void processResponse(OMElement child, OMElement bodyContent, Object resObject, DataType dataType,
SOAPFactory fac, OMNamespace defaultNS, boolean qualified, AxisService service) {
if (dataType instanceof PrimitiveDataType) {
child.addChild(fac.createOMText(child, resObject.toString()));
} else if (dataType instanceof Typedef) {
Typedef typedef = (Typedef) dataType;
AliasValue aliasValue = (AliasValue) resObject;
OMNamespace ns = getNameSpaceForType(fac, service, typedef);
OMElement item = fac.createOMElement(ARRAY_ITEM, ns, child);
processResponse(item, child, aliasValue.getValue(), typedef.getDataType(), fac, ns, qualified, service);
} else if (dataType instanceof AbstractCollectionType) {
AbstractCollectionType collectionType = (AbstractCollectionType) dataType;
AbstractCollectionValue collectionValue = (AbstractCollectionValue) resObject;
Object[] values = collectionValue.getValues();
int length = values.length;
for (int i=0; i<length; i++) {
OMElement outer = bodyContent;
if (collectionType.getDataType() instanceof AbstractCollectionType) {
outer = child;
if (qualified) {
child = fac.createOMElement(ARRAY_ITEM, defaultNS);
} else {
child = fac.createOMElement(ARRAY_ITEM, null);
}
outer.addChild(child);
}
processResponse(child, outer, values[i], collectionType.getDataType(), fac, defaultNS, qualified, service);
if (i < (length -1)) {
if (qualified) {
child = fac.createOMElement(ARRAY_ITEM, defaultNS);
} else {
child = fac.createOMElement(ARRAY_ITEM, null);
}
bodyContent.addChild(child);
}
}
} else if (dataType instanceof ValueType || dataType instanceof Struct) {
AbstractValue resValue = (AbstractValue) resObject;
Member[] members = resValue.getMembers();
Object[] memberValues = resValue.getMemberValues();
OMNamespace ns = getNameSpaceForType(fac, service, (CompositeDataType) dataType);
for (int i = 0; i < memberValues.length; i++) {
OMElement memberElement = fac.createOMElement(members[i].getName(), ns);
processResponse(memberElement, bodyContent, memberValues[i], members[i].getDataType(), fac, ns, qualified, service);
child.addChild(memberElement);
}
} else if (dataType instanceof UnionType) {
UnionValue unionValue = (UnionValue) resObject;
OMElement unMember;
OMNamespace ns = getNameSpaceForType(fac, service, (CompositeDataType) dataType);
if (qualified) {
unMember = fac.createOMElement(unionValue.getMemberName(), ns);
} else {
unMember = fac.createOMElement(unionValue.getMemberName(), null);
}
processResponse(unMember, child, unionValue.getMemberValue(), unionValue.getMemberType(), fac, ns, qualified, service);
child.addChild(unMember);
} else if (dataType instanceof EnumType) {
EnumValue enumValue = (EnumValue) resObject;
child.addChild(fac.createOMText(child, enumValue.getValueAsString()));
}
}
private static OMNamespace getNameSpaceForType(SOAPFactory fac, AxisService service, CompositeDataType dataType) {
TypeTable typeTable = service.getTypeTable();
String fullname = (dataType.getModule()!=null) ? dataType.getModule() + dataType.getName() : dataType.getName();
fullname = fullname.replaceAll(CompositeDataType.MODULE_SEPERATOR, ".");
QName qname = typeTable.getQNamefortheType(fullname);
if (qname==null)
return null;
return fac.createOMNamespace(qname.getNamespaceURI(), qname.getPrefix());
}
public static String getQualifiedName(DataType type){
if (type instanceof CompositeDataType) {
CompositeDataType compositeType = (CompositeDataType) type;
String module = compositeType.getModule();
module = (module == null) ? "" : module.replaceAll("::", ".");
return module + compositeType.getName();
} else if (type instanceof PrimitiveDataType) {
PrimitiveDataType primitiveDataType = (PrimitiveDataType) type;
return primitiveDataType.getTypeName();
}
return null;
}
public static void insertValue(Any arg, DataType type, Object value) {
switch(type.getTypeCode().kind().value()) {
case TCKind._tk_long: arg.insert_long(((Integer) value).intValue()); break;
case TCKind._tk_ulong: arg.insert_ulong(((Integer) value).intValue()); break;
case TCKind._tk_longlong: arg.insert_longlong(((Long) value).longValue()); break;
case TCKind._tk_ulonglong: arg.insert_ulonglong(((Long) value).longValue()); break;
case TCKind._tk_short: arg.insert_short(((Short) value).shortValue()); break;
case TCKind._tk_ushort: arg.insert_ushort(((Short) value).shortValue()); break;
case TCKind._tk_float: arg.insert_float(((Float) value).floatValue()); break;
case TCKind._tk_double: arg.insert_double(((Double) value).floatValue()); break;
case TCKind._tk_char: arg.insert_char(((Character) value).charValue()); break;
case TCKind._tk_wchar: arg.insert_wchar(((Character) value).charValue()); break;
case TCKind._tk_boolean: arg.insert_boolean(((Boolean) value).booleanValue()); break;
case TCKind._tk_octet: arg.insert_octet(((Byte) value).byteValue()); break;
case TCKind._tk_string: arg.insert_string((String) value); break;
case TCKind._tk_wstring: arg.insert_wstring((String) value); break;
case TCKind._tk_any: arg.insert_any((Any) value); break;
case TCKind._tk_value: arg.insert_Value((Serializable) value); break;
case TCKind._tk_objref: arg.insert_Object((org.omg.CORBA.Object) value); break;
case TCKind._tk_struct:
StructValue structValue = (StructValue) value;
org.omg.CORBA_2_3.portable.OutputStream outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(structValue.getTypeCode());
structValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), structValue.getTypeCode());
break;
case TCKind._tk_enum:
EnumValue enumValue = (EnumValue) value;
outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(enumValue.getTypeCode());
enumValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), enumValue.getTypeCode());
break;
case TCKind._tk_union:
UnionValue unionValue = (UnionValue) value;
outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(unionValue.getTypeCode());
unionValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), unionValue.getTypeCode());
break;
case TCKind._tk_alias:
AliasValue aliasValue = (AliasValue) value;
outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(aliasValue.getTypeCode());
aliasValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), aliasValue.getTypeCode());
break;
case TCKind._tk_sequence:
SequenceValue sequenceValue = (SequenceValue) value;
outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(sequenceValue.getTypeCode());
sequenceValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), sequenceValue.getTypeCode());
break;
case TCKind._tk_array:
ArrayValue arrayValue = (ArrayValue) value;
outputStream = (org.omg.CORBA_2_3.portable.OutputStream) arg.create_output_stream();
arg.type(arrayValue.getTypeCode());
arrayValue.write(outputStream);
arg.read_value(outputStream.create_input_stream (), arrayValue.getTypeCode());
break;
default:
log.error("ERROR! Invalid dataType");
break;
}
}
public static Object extractValue(DataType returnType, Any returned) {
Object returnValue = null;
TypeCode typeCode = returnType.getTypeCode();
switch(typeCode.kind().value()) {
case TCKind._tk_void: returnValue = null; break;
case TCKind._tk_long: returnValue = new Integer(returned.extract_long()); break;
case TCKind._tk_ulong: returnValue = new Integer(returned.extract_ulong()); break;
case TCKind._tk_longlong: returnValue = new Long(returned.extract_longlong()); break;
case TCKind._tk_ulonglong: returnValue = new Long(returned.extract_ulonglong()); break;
case TCKind._tk_short: returnValue = new Short(returned.extract_short()); break;
case TCKind._tk_ushort: returnValue = new Short(returned.extract_ushort()); break;
case TCKind._tk_float: returnValue = new Float(returned.extract_float()); break;
case TCKind._tk_double: returnValue = new Double(returned.extract_double()); break;
case TCKind._tk_char: returnValue = new Character(returned.extract_char()); break;
case TCKind._tk_wchar: returnValue = new Character(returned.extract_wchar()); break;
case TCKind._tk_boolean: returnValue = Boolean.valueOf(returned.extract_boolean()); break;
case TCKind._tk_octet: returnValue = new Byte(returned.extract_octet()); break;
case TCKind._tk_string: returnValue = returned.extract_string(); break;
case TCKind._tk_wstring: returnValue = returned.extract_wstring(); break;
case TCKind._tk_any: returnValue = returned.extract_any(); break;
case TCKind._tk_value: returnValue = returned.extract_Value(); break;
case TCKind._tk_objref: returnValue = returned.extract_Object(); break;
//case TCKind._tk_longdouble :
case TCKind._tk_struct:
Struct struct = (Struct) returnType;
StructValue structValue = new StructValue(struct);
org.omg.CORBA_2_3.portable.InputStream inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
structValue.read(inputStream);
returnValue = structValue;
break;
case TCKind._tk_except:
ExceptionType exceptionType = (ExceptionType) returnType;
ExceptionValue exceptionValue = new ExceptionValue(exceptionType);
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
exceptionValue.read(inputStream);
returnValue = exceptionValue;
break;
case TCKind._tk_enum:
EnumType enumType = (EnumType) returnType;
EnumValue enumValue = new EnumValue(enumType);
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
enumValue.read(inputStream);
returnValue = enumValue;
break;
case TCKind._tk_union:
UnionType unionType = (UnionType) returnType;
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
UnionValue unionValue = new UnionValue(unionType);
unionValue.read(inputStream);
returnValue = unionValue;
break;
case TCKind._tk_alias:
Typedef typedef = (Typedef) returnType;
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
AliasValue aliasValue = new AliasValue(typedef);
aliasValue.read(inputStream);
returnValue = aliasValue;
break;
case TCKind._tk_sequence:
SequenceType sequenceType = (SequenceType) returnType;
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
SequenceValue sequenceValue = new SequenceValue(sequenceType);
sequenceValue.read(inputStream);
returnValue = sequenceValue;
break;
case TCKind._tk_array:
ArrayType arrayType = (ArrayType) returnType;
inputStream = (org.omg.CORBA_2_3.portable.InputStream) returned.create_input_stream();
ArrayValue arrayValue = new ArrayValue(arrayType);
arrayValue.read(inputStream);
returnValue = arrayValue;
break;
default:
log.error("ERROR! Invalid dataType");
break;
}
return returnValue;
}
public static Object parseValue(DataType type, String value) {
if (value == null)
return null;
value = value.trim();
Object ret = null;
switch(type.getTypeCode().kind().value()) {
case TCKind._tk_long : ret = Integer.valueOf(value); break;
case TCKind._tk_ulong : ret = Integer.valueOf(value); break;
case TCKind._tk_longlong : ret = Long.valueOf(value); break;
case TCKind._tk_ulonglong : ret = Long.valueOf(value); break;
case TCKind._tk_short : ret = Short.valueOf(value); break;
case TCKind._tk_ushort : ret = Short.valueOf(value); break;
case TCKind._tk_float : ret = Float.valueOf(value); break;
case TCKind._tk_double : ret = Double.valueOf(value); break;
case TCKind._tk_char : ret = Character.valueOf(value.charAt(0)); break;
case TCKind._tk_wchar : ret = Character.valueOf(value.charAt(0)); break;
case TCKind._tk_boolean : ret = Boolean.valueOf(value); break;
case TCKind._tk_octet : ret = Byte.valueOf(value); break;
case TCKind._tk_string : ret = value; break;
case TCKind._tk_wstring : ret = value; break;
case TCKind._tk_enum :
EnumType enumType = (EnumType) type;
EnumValue enumValue = new EnumValue(enumType);
int i = enumType.getEnumMembers().indexOf(value);
enumValue.setValue(i);
ret = enumValue;
break;
default:
log.error("ERROR! Invalid dataType");
break;
}
return ret;
}
public static Object getEmptyValue(DataType type) {
switch(type.getTypeCode().kind().value()) {
case TCKind._tk_long: return new Integer(0);
case TCKind._tk_ulong: return new Integer(0);
case TCKind._tk_longlong: return new Long(0);
case TCKind._tk_ulonglong: return new Long(0);
case TCKind._tk_short: return new Short("0");
case TCKind._tk_ushort: return new Short("0");
case TCKind._tk_float: return new Float(0f);
case TCKind._tk_double: return new Double(0d);
case TCKind._tk_char: return new Character('0');
case TCKind._tk_wchar: return new Character('0');
case TCKind._tk_boolean: return Boolean.FALSE;
case TCKind._tk_octet: return new Byte("0");
case TCKind._tk_string: return "";
case TCKind._tk_wstring: return "";
//case TCKind._tk_any: return new Any();
case TCKind._tk_value: return "";
//case TCKind._tk_objref: return new org.omg.CORBA.Object();
case TCKind._tk_struct: return new StructValue((Struct) type);
case TCKind._tk_enum: return new EnumValue((EnumType) type);
case TCKind._tk_union: return new UnionValue((UnionType) type);
case TCKind._tk_alias: return new AliasValue((Typedef) type);
case TCKind._tk_sequence: return new SequenceValue((SequenceType) type);
case TCKind._tk_array: return new ArrayValue((ArrayType) type);
default:
log.error("ERROR! Invalid dataType");
}
return null;
}
}