001 /* _NamingContextStub.java -- 002 Copyright (C) 2005, 2006 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 org.omg.CORBA.MARSHAL; 042 import org.omg.CORBA.ObjectHelper; 043 import org.omg.CORBA.portable.ApplicationException; 044 import org.omg.CORBA.portable.Delegate; 045 import org.omg.CORBA.portable.InputStream; 046 import org.omg.CORBA.portable.ObjectImpl; 047 import org.omg.CORBA.portable.OutputStream; 048 import org.omg.CORBA.portable.RemarshalException; 049 import org.omg.CosNaming.NamingContextPackage.AlreadyBound; 050 import org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper; 051 import org.omg.CosNaming.NamingContextPackage.CannotProceed; 052 import org.omg.CosNaming.NamingContextPackage.CannotProceedHelper; 053 import org.omg.CosNaming.NamingContextPackage.InvalidName; 054 import org.omg.CosNaming.NamingContextPackage.InvalidNameHelper; 055 import org.omg.CosNaming.NamingContextPackage.NotEmpty; 056 import org.omg.CosNaming.NamingContextPackage.NotEmptyHelper; 057 import org.omg.CosNaming.NamingContextPackage.NotFound; 058 import org.omg.CosNaming.NamingContextPackage.NotFoundHelper; 059 060 /** 061 * The naming context stub (proxy), used on the client side. 062 * The {@link NamingContext} methods contain the code for remote 063 * invocaton. 064 * 065 * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) 066 */ 067 public class _NamingContextStub 068 extends ObjectImpl 069 implements NamingContext 070 { 071 /** 072 * Use serialVersionUID (v1.4) for interoperability. 073 */ 074 private static final long serialVersionUID = 6835430958405349379L; 075 076 /** 077 * Create the naming context stub. 078 */ 079 public _NamingContextStub() 080 { 081 super(); 082 } 083 084 /** 085 * Create the naming context stub with the given delegate. 086 */ 087 _NamingContextStub(Delegate delegate) 088 { 089 super(); 090 _set_delegate(delegate); 091 } 092 093 /** 094 * Return the array of repository ids for this object. 095 */ 096 public String[] _ids() 097 { 098 return new String[] { NamingContextHelper.id() }; 099 } 100 101 /** {@inheritDoc} */ 102 public void bind(NameComponent[] a_name, org.omg.CORBA.Object an_object) 103 throws NotFound, CannotProceed, InvalidName, AlreadyBound 104 { 105 InputStream in = null; 106 try 107 { 108 OutputStream out = _request("bind", true); 109 NameHelper.write(out, a_name); 110 ObjectHelper.write(out, an_object); 111 in = _invoke(out); 112 } 113 catch (ApplicationException ex) 114 { 115 in = ex.getInputStream(); 116 117 String id = ex.getId(); 118 throw5(in, id); 119 } 120 catch (RemarshalException remarsh) 121 { 122 bind(a_name, an_object); 123 } 124 finally 125 { 126 _releaseReply(in); 127 } 128 } 129 130 /** {@inheritDoc} */ 131 public void bind_context(NameComponent[] a_name, NamingContext a_context) 132 throws NotFound, CannotProceed, InvalidName, AlreadyBound 133 { 134 InputStream in = null; 135 try 136 { 137 OutputStream out = _request("bind_context", true); 138 NameHelper.write(out, a_name); 139 NamingContextHelper.write(out, a_context); 140 in = _invoke(out); 141 } 142 catch (ApplicationException ex) 143 { 144 in = ex.getInputStream(); 145 146 String id = ex.getId(); 147 throw5(in, id); 148 } 149 catch (RemarshalException remarsh) 150 { 151 bind_context(a_name, a_context); 152 } 153 finally 154 { 155 _releaseReply(in); 156 } 157 } 158 159 /** {@inheritDoc} */ 160 public NamingContext bind_new_context(NameComponent[] a_name) 161 throws NotFound, AlreadyBound, CannotProceed, 162 InvalidName 163 { 164 InputStream in = null; 165 try 166 { 167 OutputStream out = _request("bind_new_context", true); 168 NameHelper.write(out, a_name); 169 in = _invoke(out); 170 171 NamingContext __result = NamingContextHelper.read(in); 172 return __result; 173 } 174 catch (ApplicationException ex) 175 { 176 in = ex.getInputStream(); 177 178 String id = ex.getId(); 179 throw5(in, id); 180 throw new InternalError(); 181 } 182 catch (RemarshalException remarsh) 183 { 184 return bind_new_context(a_name); 185 } 186 finally 187 { 188 _releaseReply(in); 189 } 190 } 191 192 /** {@inheritDoc} */ 193 public void destroy() 194 throws NotEmpty 195 { 196 InputStream in = null; 197 try 198 { 199 OutputStream out = _request("destroy", true); 200 in = _invoke(out); 201 } 202 catch (ApplicationException ex) 203 { 204 in = ex.getInputStream(); 205 206 String id = ex.getId(); 207 if (id.equals(NotEmptyHelper.id())) 208 throw NotEmptyHelper.read(in); 209 else 210 throw new MARSHAL(id); 211 } 212 catch (RemarshalException remarsh) 213 { 214 destroy(); 215 } 216 finally 217 { 218 _releaseReply(in); 219 } 220 } 221 222 /** {@inheritDoc} */ 223 public void list(int amount, BindingListHolder a_list, 224 BindingIteratorHolder an_iter 225 ) 226 { 227 InputStream in = null; 228 try 229 { 230 OutputStream out = _request("list", true); 231 out.write_ulong(amount); 232 in = _invoke(out); 233 a_list.value = BindingListHelper.read(in); 234 an_iter.value = BindingIteratorHelper.read(in); 235 } 236 catch (ApplicationException ex) 237 { 238 in = ex.getInputStream(); 239 throw new MARSHAL(ex.getId()); 240 } 241 catch (RemarshalException remarsh) 242 { 243 list(amount, a_list, an_iter); 244 } 245 finally 246 { 247 _releaseReply(in); 248 } 249 } 250 251 /** {@inheritDoc} */ 252 public NamingContext new_context() 253 { 254 InputStream in = null; 255 try 256 { 257 OutputStream out = _request("new_context", true); 258 in = _invoke(out); 259 260 NamingContext __result = NamingContextHelper.read(in); 261 return __result; 262 } 263 catch (ApplicationException ex) 264 { 265 in = ex.getInputStream(); 266 throw new MARSHAL(ex.getId()); 267 } 268 catch (RemarshalException remarsh) 269 { 270 return new_context(); 271 } 272 finally 273 { 274 _releaseReply(in); 275 } 276 } 277 278 /** {@inheritDoc} */ 279 public void rebind(NameComponent[] a_name, org.omg.CORBA.Object an_object) 280 throws NotFound, CannotProceed, InvalidName 281 { 282 InputStream in = null; 283 try 284 { 285 OutputStream out = _request("rebind", true); 286 NameHelper.write(out, a_name); 287 ObjectHelper.write(out, an_object); 288 in = _invoke(out); 289 } 290 catch (ApplicationException ex) 291 { 292 in = ex.getInputStream(); 293 294 String id = ex.getId(); 295 throw4(in, id); 296 } 297 catch (RemarshalException remarsh) 298 { 299 rebind(a_name, an_object); 300 } 301 finally 302 { 303 _releaseReply(in); 304 } 305 } 306 307 /** {@inheritDoc} */ 308 public void rebind_context(NameComponent[] a_name, NamingContext a_context) 309 throws NotFound, CannotProceed, InvalidName 310 { 311 InputStream in = null; 312 try 313 { 314 OutputStream out = _request("rebind_context", true); 315 NameHelper.write(out, a_name); 316 NamingContextHelper.write(out, a_context); 317 in = _invoke(out); 318 } 319 catch (ApplicationException ex) 320 { 321 in = ex.getInputStream(); 322 323 String id = ex.getId(); 324 throw4(in, id); 325 } 326 catch (RemarshalException remarsh) 327 { 328 rebind_context(a_name, a_context); 329 } 330 finally 331 { 332 _releaseReply(in); 333 } 334 } 335 336 /** {@inheritDoc} */ 337 public org.omg.CORBA.Object resolve(NameComponent[] a_name) 338 throws NotFound, CannotProceed, InvalidName 339 { 340 InputStream in = null; 341 try 342 { 343 OutputStream out = _request("resolve", true); 344 NameHelper.write(out, a_name); 345 in = _invoke(out); 346 347 org.omg.CORBA.Object __result = ObjectHelper.read(in); 348 return __result; 349 } 350 catch (ApplicationException ex) 351 { 352 in = ex.getInputStream(); 353 354 String id = ex.getId(); 355 throw4(in, id); 356 throw new InternalError(); 357 } 358 catch (RemarshalException remarsh) 359 { 360 return resolve(a_name); 361 } 362 finally 363 { 364 _releaseReply(in); 365 } 366 } 367 368 /** {@inheritDoc} */ 369 public void unbind(NameComponent[] a_name) 370 throws NotFound, CannotProceed, InvalidName 371 { 372 InputStream in = null; 373 try 374 { 375 OutputStream out = _request("unbind", true); 376 NameHelper.write(out, a_name); 377 in = _invoke(out); 378 } 379 catch (ApplicationException ex) 380 { 381 in = ex.getInputStream(); 382 383 String id = ex.getId(); 384 if (id.equals(NotFoundHelper.id())) 385 throw NotFoundHelper.read(in); 386 else if (id.equals(CannotProceedHelper.id())) 387 throw CannotProceedHelper.read(in); 388 else if (id.equals(InvalidNameHelper.id())) 389 throw InvalidNameHelper.read(in); 390 else 391 throw new MARSHAL(id); 392 } 393 catch (RemarshalException remarsh) 394 { 395 unbind(a_name); 396 } 397 finally 398 { 399 _releaseReply(in); 400 } 401 } 402 403 /** 404 * Throw one of the three possible exceptions, as specified in 405 * the passed exception repository id. 406 * 407 * This method should never return normally. 408 * 409 * @param in the stream to read the exception from. 410 * @param id the exception id. 411 * 412 * @throws InvalidName if the id matches. 413 * @throws CannotProceed if the id matches. 414 * @throws NotFound if the id matches. 415 * @throws MARSHAL if the id does not match any of the previous 4 exceptions. 416 */ 417 void throw4(InputStream in, String id) 418 throws MARSHAL, InvalidName, CannotProceed, NotFound 419 { 420 if (id.equals(NotFoundHelper.id())) 421 throw NotFoundHelper.read(in); 422 else if (id.equals(CannotProceedHelper.id())) 423 throw CannotProceedHelper.read(in); 424 else if (id.equals(InvalidNameHelper.id())) 425 throw InvalidNameHelper.read(in); 426 else 427 throw new MARSHAL(id); 428 } 429 430 /** 431 * Throw one of the five possible exceptions, as specified in 432 * the passed exception repository id. 433 * 434 * This method should never return normally. 435 * 436 * @param in the stream to read the exception from. 437 * @param id the exception id. 438 * 439 * @throws AlreadyBound if the id matches. 440 * @throws InvalidName if the id matches. 441 * @throws CannotProceed if the id matches. 442 * @throws NotFound if the id matches. 443 * @throws MARSHAL if the id does not match any of the previous 4 exceptions. 444 */ 445 void throw5(InputStream in, String id) 446 throws MARSHAL, AlreadyBound, InvalidName, CannotProceed, 447 NotFound 448 { 449 if (id.equals(AlreadyBoundHelper.id())) 450 throw AlreadyBoundHelper.read(in); 451 else 452 throw4(in, id); 453 } 454 }