From bdd0a41aed7edf21ec2a65cfa17a86af2ef8c48a Mon Sep 17 00:00:00 2001 From: dims Date: Tue, 17 Jun 2008 00:23:01 +0000 Subject: Move Tuscany from Incubator to top level. git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68 --- .../tuscany/sca/binding/corba/types/NodeType.java | 28 +++ .../tuscany/sca/binding/corba/types/TypeTree.java | 76 +++++++ .../sca/binding/corba/types/TypeTreeCreator.java | 224 +++++++++++++++++++++ .../sca/binding/corba/types/TypeTreeNode.java | 66 ++++++ .../binding/corba/types/util/ArrayTypeHelper.java | 46 +++++ .../corba/types/util/BooleanTypeHelper.java | 45 +++++ .../binding/corba/types/util/ByteTypeHelper.java | 45 +++++ .../binding/corba/types/util/CharTypeHelper.java | 45 +++++ .../binding/corba/types/util/DoubleTypeHelper.java | 45 +++++ .../binding/corba/types/util/FloatTypeHelper.java | 45 +++++ .../binding/corba/types/util/IntTypeHelper.java | 45 +++++ .../binding/corba/types/util/LongTypeHelper.java | 46 +++++ .../corba/types/util/ReferenceTypeHelper.java | 48 +++++ .../corba/types/util/SequenceTypeHelper.java | 83 ++++++++ .../binding/corba/types/util/ShortTypeHelper.java | 46 +++++ .../binding/corba/types/util/StringTypeHelper.java | 46 +++++ .../binding/corba/types/util/StructTypeHelper.java | 90 +++++++++ .../sca/binding/corba/types/util/TypeHelper.java | 55 +++++ .../binding/corba/types/util/TypeHelpersProxy.java | 132 ++++++++++++ 19 files changed, 1256 insertions(+) create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/NodeType.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTree.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeNode.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ArrayTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/BooleanTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ByteTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/CharTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/DoubleTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/FloatTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/IntTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/LongTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ReferenceTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/SequenceTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ShortTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StringTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StructTypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelper.java create mode 100644 sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelpersProxy.java (limited to 'sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types') diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/NodeType.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/NodeType.java new file mode 100644 index 0000000000..85fc2c9f78 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/NodeType.java @@ -0,0 +1,28 @@ +/* + * 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.tuscany.sca.binding.corba.types; + +/** + * @version $Rev$ $Date$ + * Types of CORBA objects. + */ +public enum NodeType { + primitive, struct, union, array, sequence, reference +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTree.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTree.java new file mode 100644 index 0000000000..b15c1cd98e --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTree.java @@ -0,0 +1,76 @@ +/* + * 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.tuscany.sca.binding.corba.types; + +import java.util.HashMap; +import java.util.Map; + +/** + * @version $Rev$ $Date$ + * Helper tree for Java object hierarchy. It's closer to CORBA types structure + * than plain Java hierarchy - it helps reading and writing complex structures. + */ +public class TypeTree { + + private Map, TypeTreeNode> typesUsed = new HashMap, TypeTreeNode>(); + private TypeTreeNode rootNode; + + /** + * Intent was to cache previously computed type trees. In practice it caused + * a bug, and it's not being used right now. TODO: enable type trees caching + * + * @param forClass + * @param node + */ + public void addUsedType(Class forClass, TypeTreeNode node) { + typesUsed.put(forClass, node); + } + + /** + * Returns node for previously created tree, it's getter for nodes added by + * addUsedType method. Not in use right now. TODO: enable type trees caching + * + * @param forClass + * @return + */ + public TypeTreeNode getNodeForType(Class forClass) { + return typesUsed.get(forClass); + } + + /** + * Returns root node. + * + * @return root of type tree + */ + public TypeTreeNode getRootNode() { + return rootNode; + } + + /** + * Sets root of the type tree. + * + * @param rootNode + * root node. + */ + public void setRootNode(TypeTreeNode rootNode) { + this.rootNode = rootNode; + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java new file mode 100644 index 0000000000..4f79719ed4 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java @@ -0,0 +1,224 @@ +/* + * 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.tuscany.sca.binding.corba.types; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; + +/** + * @version $Rev$ $Date$ + * Creator of types tree. + * + */ +public class TypeTreeCreator { + + /** + * Helps to determine if type is a primitive. + */ + private static List> primitives = new ArrayList>(); + + static { + primitives.add(boolean.class); + primitives.add(byte.class); + primitives.add(short.class); + primitives.add(int.class); + primitives.add(long.class); + primitives.add(double.class); + primitives.add(float.class); + primitives.add(char.class); + primitives.add(String.class); + primitives.add(Boolean.class); + primitives.add(Byte.class); + primitives.add(Short.class); + primitives.add(Integer.class); + primitives.add(Long.class); + primitives.add(Double.class); + primitives.add(Float.class); + primitives.add(Character.class); + } + + /** + * Creates class for given string argument. + * + * @param name + * name of type + * @return type + */ + private static Class createClassFromString(String name) { + Class result = null; + try { + if (name.length() == 1) { + // primitives + switch (name.charAt(0)) { + case 'Z': + result = boolean.class; + break; + case 'C': + result = char.class; + break; + case 'B': + result = byte.class; + break; + case 'S': + result = short.class; + break; + case 'I': + result = int.class; + break; + case 'J': + result = long.class; + break; + case 'F': + result = float.class; + break; + case 'D': + result = double.class; + break; + } + } else { + // class + name = name.substring(1, name.length() - 1); + result = Class.forName(name); + } + } catch (Exception e) { + e.printStackTrace(); + } + return result; + } + + /** + * Reduces dimension of array. + * + * @param forClass + * array class + * @return reduced array + */ + private static Class reduceArrayDimension(Class forClass) { + String name = forClass.getName(); + try { + String reduced = name.substring(1, name.length()); + if (reduced.startsWith("[")) { + // reduced class is still an array + return Class.forName(reduced); + } else { + // reduced class may be primitive or class + return createClassFromString(reduced); + } + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + return null; + } + + /** + * Creates tree for given type. + * + * @param forClass + * @return type tree + */ + public static TypeTree createTypeTree(Class forClass) { + TypeTree tree = new TypeTree(); + TypeTreeNode rootNode = null; + rootNode = inspectClassHierarchy(forClass, tree); + tree.setRootNode(rootNode); + return tree; + + } + + /** + * Recurrent method which builds type tree. + * + * @param forClass + * @param tree + * @return + */ + private static TypeTreeNode inspectClassHierarchy(Class forClass, + TypeTree tree) { + // //remains of type tree caching + // TypeTreeNode existingNode = tree.getNodeForType(forClass); + // if (existingNode != null) { + // return existingNode; + // } + + TypeTreeNode node = createTypeNode(forClass); + NodeType nodeType = node.getNodeType(); + TypeTreeNode[] children = null; + + // //remains of type tree caching + // tree.addUsedType(forClass, node); + + if (nodeType.equals(NodeType.primitive)) { + // stop condition for recurrent method + } else if (nodeType.equals(NodeType.array)) { + // similar to sequence, but with fixed array length + // TODO: determine how array length will be declared + } else if (nodeType.equals(NodeType.sequence)) { + // reducing sequence dimension + Class reduced = reduceArrayDimension(node.getJavaClass()); + children = new TypeTreeNode[1]; + children[0] = inspectClassHierarchy(reduced, tree); + } else if (nodeType.equals(NodeType.struct)) { + // inspect types for every structure member + Field[] fields = node.getJavaClass().getFields(); + children = new TypeTreeNode[fields.length]; + for (int i = 0; i < fields.length; i++) { + Class field = fields[i].getType(); + TypeTreeNode child = inspectClassHierarchy(field, tree); + child.setName(fields[i].getName()); + children[i] = child; + } + } else if (nodeType.equals(NodeType.union)) { + // TODO: unions + } else if (nodeType.equals(NodeType.reference)) { + // TODO: CORBA references + } + + node.setChildren(children); + return node; + } + + /** + * Creating and configuring TypeTreeNode for given class. + * + * @param forClass + * class + * @return node + */ + private static TypeTreeNode createTypeNode(Class forClass) { + TypeTreeNode node = new TypeTreeNode(); + if (forClass.isArray()) { + node.setNodeType(NodeType.sequence); + node.setJavaClass(forClass); + } else if (primitives.contains(forClass)) { + node.setNodeType(NodeType.primitive); + node.setJavaClass(forClass); + node.setChildren(null); + } else if (forClass.isInterface()) { + node.setNodeType(NodeType.reference); + node.setJavaClass(forClass); + node.setChildren(null); + } else { + node.setNodeType(NodeType.struct); + node.setJavaClass(forClass); + } + return node; + } +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeNode.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeNode.java new file mode 100644 index 0000000000..c8509ff2e4 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeNode.java @@ -0,0 +1,66 @@ +/* + * 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.tuscany.sca.binding.corba.types; + +/** + * @version $Rev$ $Date$ + * Represents single tree node. + * + */ +public class TypeTreeNode { + + private NodeType nodeType; + private TypeTreeNode[] children; + private Class javaClass; + private String name; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public NodeType getNodeType() { + return nodeType; + } + + public void setNodeType(NodeType nodeType) { + this.nodeType = nodeType; + } + + public TypeTreeNode[] getChildren() { + return children; + } + + public void setChildren(TypeTreeNode[] children) { + this.children = children; + } + + public Class getJavaClass() { + return javaClass; + } + + public void setJavaClass(Class javaClass) { + this.javaClass = javaClass; + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ArrayTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ArrayTypeHelper.java new file mode 100644 index 0000000000..e1d047b543 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ArrayTypeHelper.java @@ -0,0 +1,46 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; +/** + * @version $Rev$ $Date$ + */ +public class ArrayTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + // TODO Auto-generated method stub + return null; + } + + public Object read(TypeTreeNode node, InputStream is) { + // TODO Auto-generated method stub + return null; + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + // TODO Auto-generated method stub + + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/BooleanTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/BooleanTypeHelper.java new file mode 100644 index 0000000000..681d46342b --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/BooleanTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class BooleanTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(8)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_boolean(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_boolean((Boolean) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ByteTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ByteTypeHelper.java new file mode 100644 index 0000000000..f9d58bdf9a --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ByteTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class ByteTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(10)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_octet(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_octet((Byte) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/CharTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/CharTypeHelper.java new file mode 100644 index 0000000000..393493c925 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/CharTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class CharTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(9)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_char(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_char((Character) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/DoubleTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/DoubleTypeHelper.java new file mode 100644 index 0000000000..fb4e319939 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/DoubleTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class DoubleTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(7)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_double(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_double((Double) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/FloatTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/FloatTypeHelper.java new file mode 100644 index 0000000000..ffccf94f4a --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/FloatTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class FloatTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(6)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_float(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_float((Float) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/IntTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/IntTypeHelper.java new file mode 100644 index 0000000000..ecb886333a --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/IntTypeHelper.java @@ -0,0 +1,45 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class IntTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(3)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_long(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_long((Integer) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/LongTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/LongTypeHelper.java new file mode 100644 index 0000000000..bbcdc6a07a --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/LongTypeHelper.java @@ -0,0 +1,46 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class LongTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(23)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_longlong(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_longlong((Long) data); + } + + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ReferenceTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ReferenceTypeHelper.java new file mode 100644 index 0000000000..c34e38b76d --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ReferenceTypeHelper.java @@ -0,0 +1,48 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.impl.reference.InterfaceInstanceCreator; +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.Object; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class ReferenceTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + // TODO Auto-generated method stub + return null; + } + + public java.lang.Object read(TypeTreeNode node, InputStream is) { + Object reference = is.read_Object(); + return (java.lang.Object) InterfaceInstanceCreator.createInstance(reference, node.getJavaClass()); + } + + public void write(TypeTreeNode node, OutputStream os, java.lang.Object data) { + os.write_Object((Object) data); + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/SequenceTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/SequenceTypeHelper.java new file mode 100644 index 0000000000..b14aa6f972 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/SequenceTypeHelper.java @@ -0,0 +1,83 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class SequenceTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + TypeCode typeCode = + org.omg.CORBA.ORB.init().create_alias_tc( + node.getJavaClass().getSimpleName(), + node.getJavaClass().getSimpleName(), + org.omg.CORBA.ORB.init().create_sequence_tc(0, + TypeHelpersProxy.getType(node.getChildren()[0]))); + return typeCode; + } + + public Object read(TypeTreeNode node, InputStream is) { + Object sequence = null; + try { + int size = is.read_long(); + sequence = Array.newInstance(node.getChildren()[0].getJavaClass(), + size); + for (int i = 0; i < size; i++) { + Array.set(sequence, i, TypeHelpersProxy.read( + node.getChildren()[0], is)); + } + } catch (Exception e) { + e.printStackTrace(); + } + return sequence; + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + int sum = 0; + // determine length of array + List array = new ArrayList(); + while (true) { + try { + array.add(Array.get(data, sum)); + sum++; + } catch (ArrayIndexOutOfBoundsException e) { + break; + } + } + os.write_long(sum); + Iterator iter = array.iterator(); + while (iter.hasNext()) { + Object elem = iter.next(); + TypeHelpersProxy.write(node.getChildren()[0], os, elem); + } + + } +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ShortTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ShortTypeHelper.java new file mode 100644 index 0000000000..36c89984c7 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/ShortTypeHelper.java @@ -0,0 +1,46 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class ShortTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().get_primitive_tc(org.omg.CORBA.TCKind.from_int(2)); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_short(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_short((Short) data); + } + + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StringTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StringTypeHelper.java new file mode 100644 index 0000000000..b3f22c6737 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StringTypeHelper.java @@ -0,0 +1,46 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.ORB; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class StringTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + return ORB.init().create_string_tc(0); + } + + public Object read(TypeTreeNode node, InputStream is) { + return is.read_string(); + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + os.write_string((String) data); + } + + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StructTypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StructTypeHelper.java new file mode 100644 index 0000000000..50e28cbd85 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/StructTypeHelper.java @@ -0,0 +1,90 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import java.lang.reflect.Field; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.StructMember; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public class StructTypeHelper implements TypeHelper { + + public TypeCode getType(TypeTreeNode node) { + TypeTreeNode[] children = node.getChildren(); + if (children != null) { + StructMember[] members = new StructMember[children.length]; + for (int i = 0; i < children.length; i++) { + members[i] = new StructMember(children[i].getJavaClass() + .getSimpleName(), + TypeHelpersProxy.getType(children[i]), null); + } + TypeCode result = org.omg.CORBA.ORB.init().create_struct_tc( + node.getJavaClass().getSimpleName(), + node.getJavaClass().getSimpleName(), members); + return result; + } else { + return null; + } + } + + public Object read(TypeTreeNode node, InputStream is) { + TypeTreeNode[] children = node.getChildren(); + Object result = null; + if (children != null) { + try { + result = node.getJavaClass().newInstance(); + for (int i = 0; i < children.length; i++) { + Object childResult = TypeHelpersProxy.read(children[i], is); + Field childField = result.getClass().getField( + children[i].getName()); + childField.set(result, childResult); + } + } catch (Exception e) { + // TODO: handle exception + e.printStackTrace(); + } + } + return result; + } + + public void write(TypeTreeNode node, OutputStream os, Object data) { + TypeTreeNode[] children = node.getChildren(); + if (children != null) { + try { + for (int i = 0; i < children.length; i++) { + Field childField = node.getJavaClass().getField( + children[i].getName()); + TypeHelpersProxy.write(children[i], os, childField + .get(data)); + } + } catch (Exception e) { + // TODO: handle exception + e.printStackTrace(); + } + } + } + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelper.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelper.java new file mode 100644 index 0000000000..c94fa79d83 --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelper.java @@ -0,0 +1,55 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + */ +public interface TypeHelper { + + /** + * Gets type definition for CORBA API. + * @param node + * @return + */ + TypeCode getType(TypeTreeNode node); + + /** + * Reads CORBA object + * @param node + * @param is + * @return + */ + Object read(TypeTreeNode node, InputStream is); + + /** + * Writes CORBA object + * @param node + * @param os + * @param data + */ + void write(TypeTreeNode node, OutputStream os, Object data); + +} diff --git a/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelpersProxy.java b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelpersProxy.java new file mode 100644 index 0000000000..c81f101a7e --- /dev/null +++ b/sandbox/axis2-1.4/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/util/TypeHelpersProxy.java @@ -0,0 +1,132 @@ +/* + * 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.tuscany.sca.binding.corba.types.util; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.tuscany.sca.binding.corba.types.NodeType; +import org.apache.tuscany.sca.binding.corba.types.TypeTreeNode; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +/** + * @version $Rev$ $Date$ + * Proxies getType(), write(), read() methods to appropriate TypeHelper implementation. + */ +public class TypeHelpersProxy { + + /** + * Maps primitive types to its TypeHelper implementations + */ + private static Map, TypeHelper> primitiveTypes = null; + + /** + * Maps other types to its TypeHelper implementations + */ + private static Map complexTypes = null; + + static { + // initiate type helpers + primitiveTypes = new HashMap, TypeHelper>(); + complexTypes = new HashMap(); + + primitiveTypes.put(boolean.class, new BooleanTypeHelper()); + primitiveTypes.put(char.class, new CharTypeHelper()); + primitiveTypes.put(byte.class, new ByteTypeHelper()); + primitiveTypes.put(short.class, new ShortTypeHelper()); + primitiveTypes.put(int.class, new IntTypeHelper()); + primitiveTypes.put(long.class, new LongTypeHelper()); + primitiveTypes.put(float.class, new FloatTypeHelper()); + primitiveTypes.put(double.class, new DoubleTypeHelper()); + primitiveTypes.put(String.class, new StringTypeHelper()); + primitiveTypes.put(Boolean.class, primitiveTypes.get(boolean.class)); + primitiveTypes.put(Character.class, primitiveTypes.get(char.class)); + primitiveTypes.put(Byte.class, primitiveTypes.get(byte.class)); + primitiveTypes.put(Short.class, primitiveTypes.get(short.class)); + primitiveTypes.put(Integer.class, primitiveTypes.get(int.class)); + primitiveTypes.put(Long.class, primitiveTypes.get(long.class)); + primitiveTypes.put(Float.class, primitiveTypes.get(float.class)); + primitiveTypes.put(Double.class, primitiveTypes.get(double.class)); + primitiveTypes.put(String.class, primitiveTypes.get(String.class)); + complexTypes.put(NodeType.array, new ArrayTypeHelper()); + complexTypes.put(NodeType.struct, new StructTypeHelper()); + complexTypes.put(NodeType.reference, new ReferenceTypeHelper()); + complexTypes.put(NodeType.sequence, new SequenceTypeHelper()); + } + + /** + * Gets type helper basing on given type + * + * @param node + * @return + */ + private static TypeHelper getTypeHelper(TypeTreeNode node) { + TypeHelper typeHelper = null; + NodeType type = node.getNodeType(); + if (type.equals(NodeType.primitive)) { + typeHelper = primitiveTypes.get(node.getJavaClass()); + } else { + typeHelper = complexTypes.get(type); + } + return typeHelper; + } + + /** + * Proxies getType method invocation to appropriate TypeHelper + * implementation. It's not being used since I've changed method for passing + * arguments. May be useful while implementing CORBA service bindings. + * + * @param node + * @return + */ + public static final TypeCode getType(TypeTreeNode node) { + TypeHelper typeHelper = getTypeHelper(node); + TypeCode typeCode = typeHelper.getType(node); + return typeCode; + } + + /** + * Proxies read method invocation to appropriate TypeHelper implementation. + * + * @param node + * @param is + * @return + */ + public static final Object read(TypeTreeNode node, InputStream is) { + TypeHelper helper = getTypeHelper(node); + return helper.read(node, is); + } + + /** + * Proxies write method invocation to appropriate TypeHelper implementation. + * + * @param node + * @param os + * @param data + */ + public static final void write(TypeTreeNode node, OutputStream os, + Object data) { + TypeHelper helper = getTypeHelper(node); + helper.write(node, os, data); + } + +} -- cgit v1.2.3