| /* | |
| * 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.PreProcessorInputStream; | |
| 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, ((String) orbClass.getValue()).trim()); | |
| else | |
| props.put(ORG_OMG_CORBA_ORBCLASS, DEFAULR_ORB_CLASS); | |
| if (orbSingletonClass!=null) | |
| props.put(ORG_OMG_CORBA_ORBSINGLETON_CLASS, ((String) orbSingletonClass.getValue()).trim()); | |
| 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()).trim()); | |
| NamingContextExt nc = NamingContextExtHelper.narrow(obj); | |
| obj = nc.resolve(nc.to_name(((String) objectName.getValue()).trim())); | |
| } else if (iorFilePath!=null) { | |
| FileReader fileReader = new FileReader(((String) iorFilePath.getValue()).trim()); | |
| 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()).trim()); | |
| } 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); | |
| if (idlFile == null) { | |
| throw new CorbaInvocationException("Please specify the IDL file"); | |
| } | |
| String idlFileName = ((String) idlFile.getValue()).trim(); | |
| 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; | |
| }*/ | |
| InputStream stream = new PreProcessorInputStream(dirName, idlFileName); | |
| //TODO: Set pre-processor system and user input paths | |
| 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()).trim(), 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: | |
| Struct struct = (Struct) type; | |
| StructValue value = new StructValue(struct); | |
| Member[] members = struct.getMembers(); | |
| Object[] memberValues = new Object[members.length]; | |
| for (int i = 0; i < members.length; i++) { | |
| memberValues[i] = getEmptyValue(members[i].getDataType()); | |
| } | |
| value.setMemberValues(memberValues); | |
| return value; | |
| case TCKind._tk_enum: return new EnumValue((EnumType) type); | |
| case TCKind._tk_union: | |
| UnionType unionType = (UnionType) type; | |
| UnionValue unionValue = new UnionValue(unionType); | |
| members = unionType.getMembers(); | |
| unionValue.setMemberName(members[0].getName()); | |
| unionValue.setMemberType(members[0].getDataType()); | |
| unionValue.setMemberValue(getEmptyValue(members[0].getDataType())); | |
| return unionValue; | |
| case TCKind._tk_alias: | |
| Typedef typedef = (Typedef) type; | |
| AliasValue aliasValue = new AliasValue(typedef); | |
| aliasValue.setValue(getEmptyValue(typedef.getDataType())); | |
| return aliasValue; | |
| case TCKind._tk_sequence: | |
| SequenceType sequenceType = (SequenceType) type; | |
| SequenceValue sequenceValue = new SequenceValue(sequenceType); | |
| sequenceValue.setValues(new Object[0]); | |
| return sequenceValue; | |
| case TCKind._tk_array: | |
| ArrayType arrayType = (ArrayType) type; | |
| ArrayValue arrayValue = new ArrayValue(arrayType); | |
| Object[] objects = new Object[arrayType.getElementCount()]; | |
| DataType arrayDataType = arrayType.getDataType(); | |
| for (int i = 0; i < objects.length; i++) { | |
| objects[i] = getEmptyValue(arrayDataType); | |
| } | |
| arrayValue.setValues(objects); | |
| return arrayValue; | |
| default: | |
| log.error("ERROR! Invalid dataType"); | |
| } | |
| return null; | |
| } | |
| } |