1 // Tags: not-a-test |
|
2 /* nodeHelper.java -- |
|
3 Copyright (C) 2005 Free Software Foundation, Inc. |
|
4 |
|
5 This file is part of GNU Classpath. |
|
6 |
|
7 GNU Classpath is free software; you can redistribute it and/or modify |
|
8 it under the terms of the GNU General Public License as published by |
|
9 the Free Software Foundation; either version 2, or (at your option) |
|
10 any later version. |
|
11 |
|
12 GNU Classpath is distributed in the hope that it will be useful, but |
|
13 WITHOUT ANY WARRANTY; without even the implied warranty of |
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
15 General Public License for more details. |
|
16 |
|
17 You should have received a copy of the GNU General Public License |
|
18 along with GNU Classpath; see the file COPYING. If not, write to the |
|
19 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
|
20 02111-1307 USA. |
|
21 |
|
22 Linking this library statically or dynamically with other modules is |
|
23 making a combined work based on this library. Thus, the terms and |
|
24 conditions of the GNU General Public License cover the whole |
|
25 combination. |
|
26 |
|
27 As a special exception, the copyright holders of this library give you |
|
28 permission to link this library with independent modules to produce an |
|
29 executable, regardless of the license terms of these independent |
|
30 modules, and to copy and distribute the resulting executable under |
|
31 terms of your choice, provided that you also meet, for each linked |
|
32 independent module, the terms and conditions of the license of that |
|
33 module. An independent module is a module which is not derived from |
|
34 or based on this library. If you modify this library, you may extend |
|
35 this exception to your version of the library, but you are not |
|
36 obligated to do so. If you do not wish to do so, delete this |
|
37 exception statement from your version. */ |
|
38 |
|
39 |
|
40 |
|
41 package gnu.testlet.org.omg.CORBA.ORB.communication; |
|
42 |
|
43 import org.omg.CORBA.Any; |
|
44 import org.omg.CORBA.ORB; |
|
45 import org.omg.CORBA.StructMember; |
|
46 import org.omg.CORBA.TypeCode; |
|
47 import org.omg.CORBA.portable.InputStream; |
|
48 import org.omg.CORBA.portable.OutputStream; |
|
49 |
|
50 /** |
|
51 * This class is used for various helper operations around the |
|
52 * tree {@link} structure. |
|
53 * |
|
54 * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) |
|
55 */ |
|
56 public abstract class nodeHelper |
|
57 { |
|
58 /** |
|
59 * The node repository id, used to identify the structure. |
|
60 */ |
|
61 private static String _id = |
|
62 "IDL:gnu/testlet/org/omg/CORBA/ORB/communication/node:1.0"; |
|
63 |
|
64 /** |
|
65 * Caches the typecode, allowing to compute it only once. |
|
66 */ |
|
67 private static TypeCode typeCode; |
|
68 |
|
69 /** |
|
70 * This is used to handle the recursive object references in |
|
71 * CORBA - supported way. The tree node definition is recursive, |
|
72 * as the node contains the sequence of the nodes as its field. |
|
73 */ |
|
74 private static boolean active; |
|
75 |
|
76 /** |
|
77 * Extract the tree node from the unversal CORBA wrapper, Any. |
|
78 */ |
|
79 public static node extract(Any a) |
|
80 { |
|
81 return read(a.create_input_stream()); |
|
82 } |
|
83 |
|
84 /** |
|
85 * Get the node string identifer. |
|
86 */ |
|
87 public static String id() |
|
88 { |
|
89 return _id; |
|
90 } |
|
91 |
|
92 /** |
|
93 * Insert the node into the universal CORBA wrapper, Any. |
|
94 */ |
|
95 public static void insert(Any a, node that) |
|
96 { |
|
97 OutputStream out = a.create_output_stream(); |
|
98 a.type(type()); |
|
99 write(out, that); |
|
100 a.read_value(out.create_input_stream(), type()); |
|
101 } |
|
102 |
|
103 /** |
|
104 * Read the node from the common data reprentation (CDR) stream. |
|
105 */ |
|
106 public static node read(InputStream istream) |
|
107 { |
|
108 node value = new node(); |
|
109 value.name = istream.read_string(); |
|
110 |
|
111 int _len0 = istream.read_long(); |
|
112 value.children = new node[ _len0 ]; |
|
113 for (int i = 0; i < value.children.length; ++i) |
|
114 value.children [ i ] = nodeHelper.read(istream); |
|
115 return value; |
|
116 } |
|
117 |
|
118 /** |
|
119 * Get the node type code definition. |
|
120 */ |
|
121 public static synchronized TypeCode type() |
|
122 { |
|
123 // Compute the type code only once. |
|
124 if (typeCode == null) |
|
125 { |
|
126 synchronized (TypeCode.class) |
|
127 { |
|
128 if (typeCode == null) |
|
129 { |
|
130 // To avoid the infinite recursion loop, the |
|
131 // recursive reference is handled in specific way. |
|
132 if (active) |
|
133 return ORB.init().create_recursive_tc(_id); |
|
134 active = true; |
|
135 |
|
136 // List all memebers of the node structure. |
|
137 StructMember[] members = new StructMember[ 2 ]; |
|
138 TypeCode memberType; |
|
139 memberType = ORB.init().create_string_tc(0); |
|
140 members [ 0 ] = new StructMember("name", memberType, null); |
|
141 memberType = ORB.init().create_recursive_tc(""); |
|
142 members [ 1 ] = new StructMember("children", memberType, null); |
|
143 typeCode = |
|
144 ORB.init().create_struct_tc(nodeHelper.id(), "node", members); |
|
145 active = false; |
|
146 } |
|
147 } |
|
148 } |
|
149 return typeCode; |
|
150 } |
|
151 |
|
152 /** |
|
153 * Write the node into the common data reprentation (CDR) stream. |
|
154 */ |
|
155 public static void write(OutputStream ostream, node value) |
|
156 { |
|
157 ostream.write_string(value.name); |
|
158 ostream.write_long(value.children.length); |
|
159 for (int i = 0; i < value.children.length; ++i) |
|
160 nodeHelper.write(ostream, value.children [ i ]); |
|
161 } |
|
162 } |
|