Source for org.omg.CosNaming._BindingIteratorStub

   1: /* _BindingIteratorStub.java --
   2:    Copyright (C) 2005, 2006 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package org.omg.CosNaming;
  40: 
  41: import org.omg.CORBA.MARSHAL;
  42: import org.omg.CORBA.portable.ApplicationException;
  43: import org.omg.CORBA.portable.Delegate;
  44: import org.omg.CORBA.portable.InputStream;
  45: import org.omg.CORBA.portable.ObjectImpl;
  46: import org.omg.CORBA.portable.OutputStream;
  47: import org.omg.CORBA.portable.RemarshalException;
  48: 
  49: /**
  50:  * The binding interator stub (proxy), used on the client side.
  51:  * The BindingIterator methods contains the code for remote invocaton.
  52:  *
  53:  * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
  54:  */
  55: public class _BindingIteratorStub
  56:   extends ObjectImpl
  57:   implements BindingIterator
  58: {
  59:   /**
  60:    * Use serialVersionUID (v1.4) for interoperability.
  61:    */
  62:   private static final long serialVersionUID = 8969257760771186704L;
  63: 
  64:   /**
  65:    * The object can be destroyed only once.
  66:    */
  67:   private boolean destroyed;
  68: 
  69:   /**
  70:    * Create the stub.
  71:    */
  72:   public _BindingIteratorStub()
  73:   {
  74:     super();
  75:   }
  76: 
  77:   /**
  78:    * Create the stub that used the given delegate.
  79:    */
  80:   _BindingIteratorStub(Delegate delegate)
  81:   {
  82:     super();
  83:     _set_delegate(delegate);
  84:   }
  85: 
  86:   /**
  87:    * Get an array of repository ids for this object.
  88:    */
  89:   public String[] _ids()
  90:   {
  91:     return new String[] { BindingIteratorHelper.id() };
  92:   }
  93: 
  94:   /**
  95:    * Returns true if the object has been destroyed.
  96:    */
  97:   public boolean _non_existent()
  98:   {
  99:     return destroyed;
 100:   }
 101: 
 102:   /**
 103:    * Destroys the object on the server side.
 104:    * The destruction message is sent only once, even if the method is
 105:    * called repeatedly.
 106:    */
 107:   public void destroy()
 108:   {
 109:     if (destroyed)
 110:       return;
 111: 
 112:     InputStream _in = null;
 113:     try
 114:       {
 115:         OutputStream _out = _request("destroy", true);
 116:         _in = _invoke(_out);
 117:         destroyed = true;
 118:       }
 119:     catch (ApplicationException _ex)
 120:       {
 121:         _in = _ex.getInputStream();
 122:         throw new MARSHAL(_ex.getId());
 123:       }
 124:     catch (RemarshalException _rm)
 125:       {
 126:         destroy();
 127:       }
 128:     finally
 129:       {
 130:         _releaseReply(_in);
 131:       }
 132:   }
 133: 
 134:   /** {@inheritDoc} */
 135:   public boolean next_n(int amount, BindingListHolder a_list)
 136:   {
 137:     InputStream _in = null;
 138:     try
 139:       {
 140:         OutputStream _out = _request("next_n", true);
 141:         _out.write_ulong(amount);
 142:         _in = _invoke(_out);
 143: 
 144:         boolean result = _in.read_boolean();
 145:         a_list.value = BindingListHelper.read(_in);
 146:         return result;
 147:       }
 148:     catch (ApplicationException _ex)
 149:       {
 150:         _in = _ex.getInputStream();
 151:         throw new MARSHAL(_ex.getId());
 152:       }
 153:     catch (RemarshalException _rm)
 154:       {
 155:         return next_n(amount, a_list);
 156:       }
 157:     finally
 158:       {
 159:         _releaseReply(_in);
 160:       }
 161:   }
 162: 
 163:   /** {@inheritDoc} */
 164:   public boolean next_one(BindingHolder a_binding)
 165:   {
 166:     InputStream _in = null;
 167:     try
 168:       {
 169:         OutputStream _out = _request("next_one", true);
 170:         _in = _invoke(_out);
 171: 
 172:         boolean result = _in.read_boolean();
 173:         a_binding.value = BindingHelper.read(_in);
 174:         return result;
 175:       }
 176:     catch (ApplicationException _ex)
 177:       {
 178:         _in = _ex.getInputStream();
 179:         throw new MARSHAL(_ex.getId());
 180:       }
 181:     catch (RemarshalException _rm)
 182:       {
 183:         return next_one(a_binding);
 184:       }
 185:     finally
 186:       {
 187:         _releaseReply(_in);
 188:       }
 189:   }
 190: 
 191:   /**
 192:    * Destroys the iterator instance on the server side, calling
 193:    * {@link #destroy()}.
 194:    *
 195:    * @throws java.lang.Throwable
 196:    */
 197:   protected void finalize()
 198:                    throws java.lang.Throwable
 199:   {
 200:     destroy();
 201:     super.finalize();
 202:   }