001    /* _BindingIteratorStub.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.portable.ApplicationException;
043    import org.omg.CORBA.portable.Delegate;
044    import org.omg.CORBA.portable.InputStream;
045    import org.omg.CORBA.portable.ObjectImpl;
046    import org.omg.CORBA.portable.OutputStream;
047    import org.omg.CORBA.portable.RemarshalException;
048    
049    /**
050     * The binding interator stub (proxy), used on the client side.
051     * The BindingIterator methods contains the code for remote invocaton.
052     *
053     * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
054     */
055    public class _BindingIteratorStub
056      extends ObjectImpl
057      implements BindingIterator
058    {
059      /**
060       * Use serialVersionUID (v1.4) for interoperability.
061       */
062      private static final long serialVersionUID = 8969257760771186704L;
063    
064      /**
065       * The object can be destroyed only once.
066       */
067      private boolean destroyed;
068    
069      /**
070       * Create the stub.
071       */
072      public _BindingIteratorStub()
073      {
074        super();
075      }
076    
077      /**
078       * Create the stub that used the given delegate.
079       */
080      _BindingIteratorStub(Delegate delegate)
081      {
082        super();
083        _set_delegate(delegate);
084      }
085    
086      /**
087       * Get an array of repository ids for this object.
088       */
089      public String[] _ids()
090      {
091        return new String[] { BindingIteratorHelper.id() };
092      }
093    
094      /**
095       * Returns true if the object has been destroyed.
096       */
097      public boolean _non_existent()
098      {
099        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      }
203    }