001 /* NamingContextPOA.java -- 002 Copyright (C) 2005 Free Software Foundation, Inc. 003 004 This file is part of GNU Classpath. 005 006 GNU Classpath is free software; you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation; either version 2, or (at your option) 009 any later version. 010 011 GNU Classpath is distributed in the hope that it will be useful, but 012 WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with GNU Classpath; see the file COPYING. If not, write to the 018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 019 02110-1301 USA. 020 021 Linking this library statically or dynamically with other modules is 022 making a combined work based on this library. Thus, the terms and 023 conditions of the GNU General Public License cover the whole 024 combination. 025 026 As a special exception, the copyright holders of this library give you 027 permission to link this library with independent modules to produce an 028 executable, regardless of the license terms of these independent 029 modules, and to copy and distribute the resulting executable under 030 terms of your choice, provided that you also meet, for each linked 031 independent module, the terms and conditions of the license of that 032 module. An independent module is a module which is not derived from 033 or based on this library. If you modify this library, you may extend 034 this exception to your version of the library, but you are not 035 obligated to do so. If you do not wish to do so, delete this 036 exception statement from your version. */ 037 038 039 package org.omg.CosNaming; 040 041 import gnu.CORBA.Minor; 042 043 import org.omg.CORBA.BAD_OPERATION; 044 import org.omg.CORBA.CompletionStatus; 045 import org.omg.CORBA.ObjectHelper; 046 import org.omg.CORBA.portable.InputStream; 047 import org.omg.CORBA.portable.InvokeHandler; 048 import org.omg.CORBA.portable.OutputStream; 049 import org.omg.CORBA.portable.ResponseHandler; 050 import org.omg.CosNaming.NamingContextPackage.AlreadyBound; 051 import org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper; 052 import org.omg.CosNaming.NamingContextPackage.CannotProceed; 053 import org.omg.CosNaming.NamingContextPackage.CannotProceedHelper; 054 import org.omg.CosNaming.NamingContextPackage.InvalidName; 055 import org.omg.CosNaming.NamingContextPackage.InvalidNameHelper; 056 import org.omg.CosNaming.NamingContextPackage.NotEmpty; 057 import org.omg.CosNaming.NamingContextPackage.NotEmptyHelper; 058 import org.omg.CosNaming.NamingContextPackage.NotFound; 059 import org.omg.CosNaming.NamingContextPackage.NotFoundHelper; 060 import org.omg.PortableServer.POA; 061 import org.omg.PortableServer.Servant; 062 063 /** 064 * The naming service servant. After implementing the abstract methods the 065 * instance of this class can be connected to an ORB using POA. 066 * 067 * @since 1.4 068 * 069 * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) 070 */ 071 public abstract class NamingContextPOA 072 extends Servant 073 implements NamingContextOperations, InvokeHandler 074 { 075 /** @inheritDoc */ 076 public String[] _all_interfaces(POA poa, byte[] object_ID) 077 { 078 return new String[] { NamingContextHelper.id() }; 079 } 080 081 /** 082 * The server calls this method after receiving the request message from 083 * client. The implementation base calls one of its abstract methods to 084 * perform the requested operation. 085 * 086 * @param method the method being invoked. 087 * @param in the stream to read parameters from. 088 * @param rh the handler to get a stream for writing a response. 089 * 090 * @return the stream, returned by the handler. 091 */ 092 public OutputStream _invoke(String method, InputStream in, ResponseHandler rh) 093 { 094 OutputStream out = null; 095 Integer call_method = _NamingContextImplBase.methods.get(method); 096 if (call_method == null) 097 throw new BAD_OPERATION(Minor.Method, CompletionStatus.COMPLETED_MAYBE); 098 099 switch (call_method.intValue()) 100 { 101 case 0: // bind 102 { 103 try 104 { 105 NameComponent[] a_name = NameHelper.read(in); 106 org.omg.CORBA.Object an_object = ObjectHelper.read(in); 107 bind(a_name, an_object); 108 out = rh.createReply(); 109 } 110 catch (NotFound ex) 111 { 112 out = rh.createExceptionReply(); 113 NotFoundHelper.write(out, ex); 114 } 115 catch (CannotProceed ex) 116 { 117 out = rh.createExceptionReply(); 118 CannotProceedHelper.write(out, ex); 119 } 120 catch (InvalidName ex) 121 { 122 out = rh.createExceptionReply(); 123 InvalidNameHelper.write(out, ex); 124 } 125 catch (AlreadyBound ex) 126 { 127 out = rh.createExceptionReply(); 128 AlreadyBoundHelper.write(out, ex); 129 } 130 break; 131 } 132 133 case 1: // rebind 134 { 135 try 136 { 137 NameComponent[] a_name = NameHelper.read(in); 138 org.omg.CORBA.Object an_object = ObjectHelper.read(in); 139 rebind(a_name, an_object); 140 out = rh.createReply(); 141 } 142 catch (NotFound ex) 143 { 144 out = rh.createExceptionReply(); 145 NotFoundHelper.write(out, ex); 146 } 147 catch (CannotProceed ex) 148 { 149 out = rh.createExceptionReply(); 150 CannotProceedHelper.write(out, ex); 151 } 152 catch (InvalidName ex) 153 { 154 out = rh.createExceptionReply(); 155 InvalidNameHelper.write(out, ex); 156 } 157 break; 158 } 159 160 case 2: // bind_context 161 { 162 try 163 { 164 NameComponent[] a_name = NameHelper.read(in); 165 NamingContext a_context = NamingContextHelper.read(in); 166 bind_context(a_name, a_context); 167 out = rh.createReply(); 168 } 169 catch (NotFound ex) 170 { 171 out = rh.createExceptionReply(); 172 NotFoundHelper.write(out, ex); 173 } 174 catch (CannotProceed ex) 175 { 176 out = rh.createExceptionReply(); 177 CannotProceedHelper.write(out, ex); 178 } 179 catch (InvalidName ex) 180 { 181 out = rh.createExceptionReply(); 182 InvalidNameHelper.write(out, ex); 183 } 184 catch (AlreadyBound ex) 185 { 186 out = rh.createExceptionReply(); 187 AlreadyBoundHelper.write(out, ex); 188 } 189 break; 190 } 191 192 case 3: // rebind_context 193 { 194 try 195 { 196 NameComponent[] a_name = NameHelper.read(in); 197 NamingContext a_context = NamingContextHelper.read(in); 198 rebind_context(a_name, a_context); 199 out = rh.createReply(); 200 } 201 catch (NotFound ex) 202 { 203 out = rh.createExceptionReply(); 204 NotFoundHelper.write(out, ex); 205 } 206 catch (CannotProceed ex) 207 { 208 out = rh.createExceptionReply(); 209 CannotProceedHelper.write(out, ex); 210 } 211 catch (InvalidName ex) 212 { 213 out = rh.createExceptionReply(); 214 InvalidNameHelper.write(out, ex); 215 } 216 break; 217 } 218 219 case 4: // resolve 220 { 221 try 222 { 223 NameComponent[] a_name = NameHelper.read(in); 224 org.omg.CORBA.Object __result = null; 225 __result = resolve(a_name); 226 out = rh.createReply(); 227 ObjectHelper.write(out, __result); 228 } 229 catch (NotFound ex) 230 { 231 out = rh.createExceptionReply(); 232 NotFoundHelper.write(out, ex); 233 } 234 catch (CannotProceed ex) 235 { 236 out = rh.createExceptionReply(); 237 CannotProceedHelper.write(out, ex); 238 } 239 catch (InvalidName ex) 240 { 241 out = rh.createExceptionReply(); 242 InvalidNameHelper.write(out, ex); 243 } 244 break; 245 } 246 247 case 5: // unbind 248 { 249 try 250 { 251 NameComponent[] a_name = NameHelper.read(in); 252 unbind(a_name); 253 out = rh.createReply(); 254 } 255 catch (NotFound ex) 256 { 257 out = rh.createExceptionReply(); 258 NotFoundHelper.write(out, ex); 259 } 260 catch (CannotProceed ex) 261 { 262 out = rh.createExceptionReply(); 263 CannotProceedHelper.write(out, ex); 264 } 265 catch (InvalidName ex) 266 { 267 out = rh.createExceptionReply(); 268 InvalidNameHelper.write(out, ex); 269 } 270 break; 271 } 272 273 case 6: // new_context 274 { 275 NamingContext __result = null; 276 __result = new_context(); 277 out = rh.createReply(); 278 NamingContextHelper.write(out, __result); 279 break; 280 } 281 282 case 7: // bind_new_context 283 { 284 try 285 { 286 NameComponent[] a_name = NameHelper.read(in); 287 NamingContext __result = null; 288 __result = bind_new_context(a_name); 289 out = rh.createReply(); 290 NamingContextHelper.write(out, __result); 291 } 292 catch (NotFound ex) 293 { 294 out = rh.createExceptionReply(); 295 NotFoundHelper.write(out, ex); 296 } 297 catch (AlreadyBound ex) 298 { 299 out = rh.createExceptionReply(); 300 AlreadyBoundHelper.write(out, ex); 301 } 302 catch (CannotProceed ex) 303 { 304 out = rh.createExceptionReply(); 305 CannotProceedHelper.write(out, ex); 306 } 307 catch (InvalidName ex) 308 { 309 out = rh.createExceptionReply(); 310 InvalidNameHelper.write(out, ex); 311 } 312 break; 313 } 314 315 case 8: // destroy 316 { 317 try 318 { 319 destroy(); 320 out = rh.createReply(); 321 } 322 catch (NotEmpty ex) 323 { 324 out = rh.createExceptionReply(); 325 NotEmptyHelper.write(out, ex); 326 } 327 break; 328 } 329 330 case 9: // list 331 { 332 int amount = in.read_ulong(); 333 BindingListHolder a_list = new BindingListHolder(); 334 BindingIteratorHolder an_iter = new BindingIteratorHolder(); 335 list(amount, a_list, an_iter); 336 out = rh.createReply(); 337 BindingListHelper.write(out, a_list.value); 338 BindingIteratorHelper.write(out, an_iter.value); 339 break; 340 } 341 342 default: 343 throw new BAD_OPERATION(0, CompletionStatus.COMPLETED_MAYBE); 344 } 345 346 return out; 347 } 348 349 /** 350 * Get the CORBA object that delegates calls to this servant. The servant must 351 * be already connected to an ORB. 352 */ 353 public NamingContext _this() 354 { 355 return NamingContextHelper.narrow(super._this_object()); 356 } 357 358 /** 359 * Get the CORBA object that delegates calls to this servant. Connect to the 360 * given ORB, if needed. 361 */ 362 public NamingContext _this(org.omg.CORBA.ORB orb) 363 { 364 return NamingContextHelper.narrow(super._this_object(orb)); 365 } 366 367 }