001/* _NamingContextImplBase.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.DynamicImplementation;
046import org.omg.CORBA.ObjectHelper;
047import org.omg.CORBA.ObjectHolder;
048import org.omg.CORBA.ServerRequest;
049import org.omg.CORBA.portable.InputStream;
050import org.omg.CORBA.portable.InvokeHandler;
051import org.omg.CORBA.portable.OutputStream;
052import org.omg.CORBA.portable.ResponseHandler;
053import org.omg.CORBA.portable.Streamable;
054import org.omg.CosNaming.NamingContextPackage.AlreadyBound;
055import org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper;
056import org.omg.CosNaming.NamingContextPackage.CannotProceed;
057import org.omg.CosNaming.NamingContextPackage.CannotProceedHelper;
058import org.omg.CosNaming.NamingContextPackage.InvalidName;
059import org.omg.CosNaming.NamingContextPackage.InvalidNameHelper;
060import org.omg.CosNaming.NamingContextPackage.NotEmpty;
061import org.omg.CosNaming.NamingContextPackage.NotEmptyHelper;
062import org.omg.CosNaming.NamingContextPackage.NotFound;
063import org.omg.CosNaming.NamingContextPackage.NotFoundHelper;
064
065import java.util.Hashtable;
066
067/**
068 * The naming context implementation base.
069 *
070 * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
071 */
072public abstract class _NamingContextImplBase
073  extends DynamicImplementation
074  implements NamingContext, InvokeHandler
075{
076  /**
077   * Use serialVersionUID (v1.4) for interoperability.
078   */
079  private static final long serialVersionUID = -114280294134561035L;
080
081  /**
082   * As there are quite many methods, it may be sensible to use the hashtable.
083   * This field is also reused in NamingContextPOA.
084   */
085  static Hashtable<String,Integer> methods = new Hashtable<String,Integer>();
086
087  /**
088   * Put all methods into the table.
089   */
090  static
091  {
092    methods.put("bind", new Integer(0));
093    methods.put("rebind", new Integer(1));
094    methods.put("bind_context", new Integer(2));
095    methods.put("rebind_context", new Integer(3));
096    methods.put("resolve", new Integer(4));
097    methods.put("unbind", new Integer(5));
098    methods.put("new_context", new Integer(6));
099    methods.put("bind_new_context", new Integer(7));
100    methods.put("destroy", new Integer(8));
101    methods.put("list", new Integer(9));
102  }
103
104  /**
105   * Return the array of repository ids.
106   */
107  public String[] _ids()
108  {
109    return new String[] { NamingContextHelper.id() };
110  }
111
112  /**
113   * The server calls this method after receiving the request message
114   * from client. The implementation base calls one of its abstract
115   * methods to perform the requested operation.
116   *
117   * @param method the method being invoked.
118   * @param in the stream to read parameters from.
119   * @param rh the handler to get a stream for writing a response.
120   *
121   * @return the stream, returned by the handler.
122   */
123  public OutputStream _invoke(String method, InputStream in, ResponseHandler rh)
124  {
125    OutputStream out = null;
126    Integer call_method = methods.get(method);
127    if (call_method == null)
128      throw new BAD_OPERATION(Minor.Method, CompletionStatus.COMPLETED_MAYBE);
129
130    switch (call_method.intValue())
131      {
132        case 0 : // bind
133        {
134          try
135            {
136              NameComponent[] a_name = NameHelper.read(in);
137              org.omg.CORBA.Object an_object = ObjectHelper.read(in);
138              bind(a_name, an_object);
139              out = rh.createReply();
140            }
141          catch (NotFound ex)
142            {
143              out = rh.createExceptionReply();
144              NotFoundHelper.write(out, ex);
145            }
146          catch (CannotProceed ex)
147            {
148              out = rh.createExceptionReply();
149              CannotProceedHelper.write(out, ex);
150            }
151          catch (InvalidName ex)
152            {
153              out = rh.createExceptionReply();
154              InvalidNameHelper.write(out, ex);
155            }
156          catch (AlreadyBound ex)
157            {
158              out = rh.createExceptionReply();
159              AlreadyBoundHelper.write(out, ex);
160            }
161          break;
162        }
163
164        case 1 : // rebind
165        {
166          try
167            {
168              NameComponent[] a_name = NameHelper.read(in);
169              org.omg.CORBA.Object an_object = ObjectHelper.read(in);
170              rebind(a_name, an_object);
171              out = rh.createReply();
172            }
173          catch (NotFound ex)
174            {
175              out = rh.createExceptionReply();
176              NotFoundHelper.write(out, ex);
177            }
178          catch (CannotProceed ex)
179            {
180              out = rh.createExceptionReply();
181              CannotProceedHelper.write(out, ex);
182            }
183          catch (InvalidName ex)
184            {
185              out = rh.createExceptionReply();
186              InvalidNameHelper.write(out, ex);
187            }
188          break;
189        }
190
191        case 2 : // bind_context
192        {
193          try
194            {
195              NameComponent[] a_name = NameHelper.read(in);
196              NamingContext a_context = NamingContextHelper.read(in);
197              bind_context(a_name, a_context);
198              out = rh.createReply();
199            }
200          catch (NotFound ex)
201            {
202              out = rh.createExceptionReply();
203              NotFoundHelper.write(out, ex);
204            }
205          catch (CannotProceed ex)
206            {
207              out = rh.createExceptionReply();
208              CannotProceedHelper.write(out, ex);
209            }
210          catch (InvalidName ex)
211            {
212              out = rh.createExceptionReply();
213              InvalidNameHelper.write(out, ex);
214            }
215          catch (AlreadyBound ex)
216            {
217              out = rh.createExceptionReply();
218              AlreadyBoundHelper.write(out, ex);
219            }
220          break;
221        }
222
223        case 3 : // rebind_context
224        {
225          try
226            {
227              NameComponent[] a_name = NameHelper.read(in);
228              NamingContext a_context = NamingContextHelper.read(in);
229              rebind_context(a_name, a_context);
230              out = rh.createReply();
231            }
232          catch (NotFound ex)
233            {
234              out = rh.createExceptionReply();
235              NotFoundHelper.write(out, ex);
236            }
237          catch (CannotProceed ex)
238            {
239              out = rh.createExceptionReply();
240              CannotProceedHelper.write(out, ex);
241            }
242          catch (InvalidName ex)
243            {
244              out = rh.createExceptionReply();
245              InvalidNameHelper.write(out, ex);
246            }
247          break;
248        }
249
250        case 4 : // resolve
251        {
252          try
253            {
254              NameComponent[] a_name = NameHelper.read(in);
255              org.omg.CORBA.Object __result = null;
256              __result = resolve(a_name);
257              out = rh.createReply();
258              ObjectHelper.write(out, __result);
259            }
260          catch (NotFound ex)
261            {
262              out = rh.createExceptionReply();
263              NotFoundHelper.write(out, ex);
264            }
265          catch (CannotProceed ex)
266            {
267              out = rh.createExceptionReply();
268              CannotProceedHelper.write(out, ex);
269            }
270          catch (InvalidName ex)
271            {
272              out = rh.createExceptionReply();
273              InvalidNameHelper.write(out, ex);
274            }
275          break;
276        }
277
278        case 5 : // unbind
279        {
280          try
281            {
282              NameComponent[] a_name = NameHelper.read(in);
283              unbind(a_name);
284              out = rh.createReply();
285            }
286          catch (NotFound ex)
287            {
288              out = rh.createExceptionReply();
289              NotFoundHelper.write(out, ex);
290            }
291          catch (CannotProceed ex)
292            {
293              out = rh.createExceptionReply();
294              CannotProceedHelper.write(out, ex);
295            }
296          catch (InvalidName ex)
297            {
298              out = rh.createExceptionReply();
299              InvalidNameHelper.write(out, ex);
300            }
301          break;
302        }
303
304        case 6 : // new_context
305        {
306          NamingContext __result = null;
307          __result = new_context();
308          out = rh.createReply();
309          NamingContextHelper.write(out, __result);
310          break;
311        }
312
313        case 7 : // bind_new_context
314        {
315          try
316            {
317              NameComponent[] a_name = NameHelper.read(in);
318              NamingContext __result = null;
319              __result = bind_new_context(a_name);
320              out = rh.createReply();
321              NamingContextHelper.write(out, __result);
322            }
323          catch (NotFound ex)
324            {
325              out = rh.createExceptionReply();
326              NotFoundHelper.write(out, ex);
327            }
328          catch (AlreadyBound ex)
329            {
330              out = rh.createExceptionReply();
331              AlreadyBoundHelper.write(out, ex);
332            }
333          catch (CannotProceed ex)
334            {
335              out = rh.createExceptionReply();
336              CannotProceedHelper.write(out, ex);
337            }
338          catch (InvalidName ex)
339            {
340              out = rh.createExceptionReply();
341              InvalidNameHelper.write(out, ex);
342            }
343          break;
344        }
345
346        case 8 : // destroy
347        {
348          try
349            {
350              destroy();
351              out = rh.createReply();
352            }
353          catch (NotEmpty ex)
354            {
355              out = rh.createExceptionReply();
356              NotEmptyHelper.write(out, ex);
357            }
358          break;
359        }
360
361        case 9 : // list
362        {
363          int amount = in.read_ulong();
364          BindingListHolder a_list = new BindingListHolder();
365          BindingIteratorHolder an_iter = new BindingIteratorHolder();
366          list(amount, a_list, an_iter);
367          out = rh.createReply();
368          BindingListHelper.write(out, a_list.value);
369          BindingIteratorHelper.write(out, an_iter.value);
370          break;
371        }
372
373        default :
374          throw new BAD_OPERATION(0, CompletionStatus.COMPLETED_MAYBE);
375      }
376
377    return out;
378  }
379
380  /**
381   * The obsolete invocation using server request. Implemented for
382   * compatibility reasons, but is it more effectinve to use
383   * {@link #_invoke}.
384   *
385   * @param request a server request.
386   */
387  public void invoke(ServerRequest request)
388  {
389    Streamable result = null;
390
391    // The server request contains no required result type.
392    Integer call_method = methods.get(request.operation());
393    if (call_method == null)
394      throw new BAD_OPERATION(Minor.Method, CompletionStatus.COMPLETED_MAYBE);
395
396    switch (call_method.intValue())
397      {
398        case 4 : // resolve, object
399          result = new ObjectHolder();
400          break;
401
402        case 6 : // new_context, NamingContext
403        case 7 : // bind_new_context, NamingContext
404        {
405          result = new NamingContextHolder();
406          break;
407        }
408
409        default : // void for others.
410          result = null;
411      }
412
413    gnu.CORBA.ServiceRequestAdapter.invoke(request, this, result);
414  }
415}