001/* NamingContextPOA.java --
002   Copyright (C) 2005 Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package org.omg.CosNaming;
040
041import gnu.CORBA.Minor;
042
043import org.omg.CORBA.BAD_OPERATION;
044import org.omg.CORBA.CompletionStatus;
045import org.omg.CORBA.ObjectHelper;
046import org.omg.CORBA.portable.InputStream;
047import org.omg.CORBA.portable.InvokeHandler;
048import org.omg.CORBA.portable.OutputStream;
049import org.omg.CORBA.portable.ResponseHandler;
050import org.omg.CosNaming.NamingContextPackage.AlreadyBound;
051import org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper;
052import org.omg.CosNaming.NamingContextPackage.CannotProceed;
053import org.omg.CosNaming.NamingContextPackage.CannotProceedHelper;
054import org.omg.CosNaming.NamingContextPackage.InvalidName;
055import org.omg.CosNaming.NamingContextPackage.InvalidNameHelper;
056import org.omg.CosNaming.NamingContextPackage.NotEmpty;
057import org.omg.CosNaming.NamingContextPackage.NotEmptyHelper;
058import org.omg.CosNaming.NamingContextPackage.NotFound;
059import org.omg.CosNaming.NamingContextPackage.NotFoundHelper;
060import org.omg.PortableServer.POA;
061import 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 */
071public 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}