1 files changed, 443 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/CORBA/NamingService/TransientContext.java b/libjava/classpath/gnu/CORBA/NamingService/TransientContext.java
new file mode 100644
index 000000000..6ed07d799
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/NamingService/TransientContext.java
@@ -0,0 +1,443 @@
+/* nContext.java -- implementation of NamingContext
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.CORBA.NamingService;
+
+import org.omg.CORBA.Object;
+import org.omg.CosNaming.Binding;
+import org.omg.CosNaming.BindingIteratorHolder;
+import org.omg.CosNaming.BindingListHolder;
+import org.omg.CosNaming.BindingType;
+import org.omg.CosNaming.NameComponent;
+import org.omg.CosNaming.NamingContext;
+import org.omg.CosNaming.NamingContextOperations;
+import org.omg.CosNaming.NamingContextPackage.AlreadyBound;
+import org.omg.CosNaming.NamingContextPackage.CannotProceed;
+import org.omg.CosNaming.NamingContextPackage.InvalidName;
+import org.omg.CosNaming.NamingContextPackage.NotEmpty;
+import org.omg.CosNaming.NamingContextPackage.NotFound;
+import org.omg.CosNaming.NamingContextPackage.NotFoundReason;
+import org.omg.CosNaming._NamingContextImplBase;
+
+import gnu.CORBA.SafeForDirectCalls;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * This class implements the transient naming service, defined by
+ * {@link NamingContext}. The 'transient' means that the service does
+ * not store its state into the persistent memory. If the service is
+ * restarted, the named objects must be re-registered again.
+ *
+ * TODO Write the persistent naming service.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class TransientContext
+  extends _NamingContextImplBase
+  implements NamingContext, NamingContextOperations, SafeForDirectCalls
+{
+  /**
+   * Use serial version UID for interoperability.
+   */
+  private static final long serialVersionUID = 2;
+
+  /**
+   * The already named contexts.
+   */
+  protected final NamingMap named_contexts;
+
+  /**
+   * The already named objects.
+   */
+  protected final NamingMap named_objects;
+
+  /**
+   * Create the naming conetxt with default (transient) naming maps.
+   */
+  public TransientContext()
+  {
+    this(new NamingMap(), new NamingMap());
+  }
+
+  /**
+   * Create the naming conetxt with the two provided naming maps.
+   *
+   * @param context_map the map for contexts
+   * @param object_map the map for objectss
+   */
+  public TransientContext(NamingMap context_map, NamingMap object_map)
+  {
+    named_contexts = context_map;
+    named_objects = object_map;
+  }
+
+  /**
+   * Gives the object a name, valid in this context.
+   *
+   * @param a_name the name, being given to the object.
+   * @param an_object the object, being named.
+   *
+   * @throws AlreadyBound if the object is already named in this context.
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public void bind(NameComponent[] a_name, Object an_object)
+            throws NotFound, CannotProceed, InvalidName, AlreadyBound
+  {
+    if (a_name.length == 1)
+      named_objects.bind(a_name [ 0 ], an_object);
+    else
+      {
+        NamingContext context =
+          (NamingContext) named_contexts.get(a_name [ 0 ]);
+        context.bind(getSuffix(a_name), an_object);
+      }
+  }
+
+  /**
+   * Gives a child context name, valid in this context.
+   *
+   * @param a_name the name, being given to the child context.
+   * @param a_context the child context being named.
+   *
+   * @throws AlreadyBound if the child context is already named in
+   * the current context.
+   */
+  public void bind_context(NameComponent[] a_name, NamingContext a_context)
+                    throws NotFound, CannotProceed, InvalidName, AlreadyBound
+  {
+    if (a_name.length == 1)
+      named_contexts.bind(a_name [ 0 ], a_context);
+    else
+      {
+        NamingContext context =
+          (NamingContext) named_contexts.get(a_name [ 0 ]);
+        context.bind_context(getSuffix(a_name), a_context);
+      }
+  }
+
+  /**
+   * Create a new context and give it a given name (bound it)
+   * in the current context.
+   *
+   * The context being created is returned by calling
+   * {@link #new_context()}.
+   *
+   * @param a_name the name being given to the new context.
+   *
+   * @return the newly created context.
+   *
+   * @throws AlreadyBound if the name is already in use.
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public NamingContext bind_new_context(NameComponent[] a_name)
+                                 throws NotFound, AlreadyBound, CannotProceed,
+                                        InvalidName
+  {
+    if (named_contexts.containsKey(a_name [ 0 ]) ||
+        named_objects.containsKey(a_name [ 0 ])
+       )
+      throw new AlreadyBound();
+
+    NamingContext child = new_context();
+    bind_context(a_name, child);
+    return child;
+  }
+
+  /**
+   * Destroy this context (must be empty).
+   * @throws NotEmpty if the context being destroyed is not empty.
+   */
+  public void destroy()
+               throws NotEmpty
+  {
+    if (named_contexts.size() > 0 || named_objects.size() > 0)
+      throw new NotEmpty();
+  }
+
+  /**
+   * Iterate over all bindings, defined in this namind context.
+   *
+   * @param amount the maximal number of context to return in the
+   * holder a_list. The remaining bindings are accessible via iterator
+   * an_iter. If the parameter amount is zero, all bindings are accessed only
+   * via this iterator.
+   *
+   * This implementation list contexts first, then objects.
+   *
+   * @param a_list the holder, where the returned bindigs are stored.
+   * @param an_iter the iterator that can be used to access the remaining
+   * bindings.
+   */
+  public void list(int amount, BindingListHolder a_list,
+                   BindingIteratorHolder an_iter
+                  )
+  {
+    int nb = named_contexts.size() + named_objects.size();
+    int nl = nb;
+    if (nl > amount)
+      nl = amount;
+
+    a_list.value = new Binding[ nl ];
+
+    Iterator contexts = named_contexts.entries().iterator();
+    Iterator objects = named_objects.entries().iterator();
+
+    // Create a binding list.
+    for (int i = 0; i < nl; i++)
+      {
+        if (contexts.hasNext())
+          a_list.value [ i ] = mkBinding(contexts.next(), BindingType.ncontext);
+        else if (objects.hasNext())
+          a_list.value [ i ] = mkBinding(objects.next(), BindingType.nobject);
+        else
+          throw new InternalError();
+      }
+
+    // Create an iterator.
+    Binding[] remainder = new Binding[ nb - nl ];
+    int p = 0;
+
+    while (contexts.hasNext())
+      remainder [ p++ ] = mkBinding(contexts.next(), BindingType.ncontext);
+
+    while (objects.hasNext())
+      remainder [ p++ ] = mkBinding(objects.next(), BindingType.nobject);
+
+    Binding_iterator_impl bit = new Binding_iterator_impl(remainder);
+    _orb().connect(bit);
+    an_iter.value = bit;
+  }
+
+  /**
+   * Creates a new naming context, not bound to any name.
+   */
+  public NamingContext new_context()
+  {
+    Ext context = new Ext(new TransientContext());
+
+    // Connect the context to the current ORB:
+    _orb().connect(context);
+    return context;
+  }
+
+  /**
+   * Names or renames the object.
+   *
+   * @param a_name the new name, being given to the object
+   * in the scope of the current context. If the object is already
+   * named in this context, it is renamed.
+   *
+   * @param an_object the object, being named.
+   *
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public void rebind(NameComponent[] a_name, Object an_object)
+              throws NotFound, CannotProceed, InvalidName
+  {
+    if (a_name.length == 1)
+      named_objects.rebind(a_name [ 0 ], an_object);
+    else
+      {
+        NamingContext context =
+          (NamingContext) named_contexts.get(a_name [ 0 ]);
+        context.rebind(getSuffix(a_name), an_object);
+      }
+  }
+
+  /**
+   * Names or renames the child context.
+   * If the child context is already named in
+   * the current context, it is renamed. The the name being given is in
+   * use, the old meaning of the name is discarded.
+   *
+   * @param a_name the name, being given to the child context in the scope
+   * of the current context.
+   *
+   * @param a_context the child context being named.
+   *
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public void rebind_context(NameComponent[] a_name, NamingContext a_context)
+                      throws NotFound, CannotProceed, InvalidName
+  {
+    if (a_name.length == 1)
+      named_contexts.rebind(a_name [ 0 ], a_context);
+    else
+      {
+        NamingContext context =
+          (NamingContext) named_contexts.get(a_name [ 0 ]);
+        context.rebind_context(getSuffix(a_name), a_context);
+      }
+  }
+
+  /**
+   * Get the object, bound to the specified name in this
+   * context. The given object must match the bound
+   * name.
+   *
+   * This implementation resolves the names as defined in specification
+   * of the CORBA naming service. This means, if the beginning of the
+   * name can be resolved to some naming context, the request is
+   * forwarded to this context, passing the unresolved name part as a
+   * parameter. In this way, it is possible to have a hierarchy of the
+   * naming services. The central services resolve the the beginning
+   * of the name. The local services resolve the remaining nodes of the
+   * name that may be relevant to some local details. It can be three or
+   * more ranks of the naming services.
+   *
+   * @param a_name the object name.
+   *
+   * @return the object, matching this name. The client
+   * usually casts or narrows (using the helper) the returned value
+   * to the more specific type.
+   *
+   * @throws NotFound if the name cannot be resolved.
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public Object resolve(NameComponent[] a_name)
+                 throws NotFound, CannotProceed, InvalidName
+  {
+    NameValidator.check(a_name);
+
+    if (a_name.length > 1)
+      return resolveSubContext(a_name);
+    else
+      {
+        // A single node name.
+        org.omg.CORBA.Object object;
+
+        object = named_objects.get(a_name [ 0 ]);
+        if (object != null)
+          return object;
+
+        object = named_contexts.get(a_name [ 0 ]);
+        if (object != null)
+          return object;
+      }
+
+    throw new NotFound(NotFoundReason.missing_node, a_name);
+  }
+
+  /**
+   * Removes the name from the binding context.
+   *
+   * @param a_name a name to remove.
+   *
+   * @throws InvalidName if the name has zero length or otherwise invalid.
+   */
+  public void unbind(NameComponent[] a_name)
+              throws NotFound, CannotProceed, InvalidName
+  {
+    NameValidator.check(a_name);
+
+    // Single node name - handle it.
+    if (a_name.length == 1)
+      {
+        if (named_objects.containsKey(a_name [ 0 ]))
+          named_objects.remove(a_name [ 0 ]);
+        else if (named_contexts.containsKey(a_name [ 0 ]))
+          named_contexts.remove(a_name [ 0 ]);
+        else
+          throw new NotFound(NotFoundReason.missing_node, a_name);
+      }
+    else
+      {
+        // Handle the first node and forward the command.
+        NamingContext subcontext =
+          (NamingContext) named_contexts.get(a_name [ 0 ]);
+
+        if (subcontext == null)
+          throw new NotFound(NotFoundReason.missing_node, a_name);
+
+        subcontext.unbind(getSuffix(a_name));
+      }
+  }
+
+  /**
+   * Get the name suffix, discarding the first member.
+   */
+  private NameComponent[] getSuffix(NameComponent[] a_name)
+  {
+    NameComponent[] suffix = new NameComponent[ a_name.length - 1 ];
+    System.arraycopy(a_name, 1, suffix, 0, suffix.length);
+    return suffix;
+  }
+
+  /**
+   * Create a binding.
+   *
+   * @param an_entry the entry, defining the bound object.
+   * @param type the binding type.
+   * @return the created binding.
+   */
+  private Binding mkBinding(java.lang.Object an_entry, BindingType type)
+  {
+    Map.Entry entry = (Map.Entry) an_entry;
+    Binding b = new Binding();
+
+    // The name component has always only one node (the current context)
+    b.binding_name = new NameComponent[] { (NameComponent) entry.getKey() };
+    b.binding_type = type;
+    return b;
+  }
+
+  /**
+   * Find the context, bound to the first name of the given
+   * name, and pass the remainder (without the first node)
+   * of the name for that context to resolve.
+   *
+   * @param a_name the name to resolve.
+   *
+   * @return the resolved context
+   */
+  private Object resolveSubContext(NameComponent[] a_name)
+                            throws NotFound, CannotProceed, InvalidName
+  {
+    // A multiple node name.
+    // This context resolves the first node only.
+    NamingContext context = (NamingContext) named_contexts.get(a_name [ 0 ]);
+    if (context == null)
+      throw new NotFound(NotFoundReason.missing_node, a_name);
+
+    NameComponent[] suffix = getSuffix(a_name);
+
+    return context.resolve(suffix);
+  }
+}