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 --- .../sca/binding/corba/types/TypeTreeCreator.java | 224 +++++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 sandbox/sebastien/java/sca-node/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java (limited to 'sandbox/sebastien/java/sca-node/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java') diff --git a/sandbox/sebastien/java/sca-node/modules/binding-corba/src/main/java/org/apache/tuscany/sca/binding/corba/types/TypeTreeCreator.java b/sandbox/sebastien/java/sca-node/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/sebastien/java/sca-node/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; + } +} -- cgit v1.2.3