mirror of git://gcc.gnu.org/git/gcc.git
957 lines
29 KiB
Java
957 lines
29 KiB
Java
/* ContextContinuation.java -- handles corbaname: urls
|
|
Copyright (C) 2006 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.javax.naming.giop;
|
|
|
|
import gnu.CORBA.NamingService.Ext;
|
|
import gnu.CORBA.NamingService.NameTransformer;
|
|
|
|
import java.util.Hashtable;
|
|
|
|
import javax.naming.Binding;
|
|
import javax.naming.Context;
|
|
import javax.naming.ContextNotEmptyException;
|
|
import javax.naming.InvalidNameException;
|
|
import javax.naming.Name;
|
|
import javax.naming.NameAlreadyBoundException;
|
|
import javax.naming.NameClassPair;
|
|
import javax.naming.NameNotFoundException;
|
|
import javax.naming.NameParser;
|
|
import javax.naming.NamingEnumeration;
|
|
import javax.naming.NamingException;
|
|
import javax.naming.OperationNotSupportedException;
|
|
import javax.naming.directory.InvalidAttributesException;
|
|
|
|
import org.omg.CORBA.ORB;
|
|
import org.omg.CORBA.portable.Delegate;
|
|
import org.omg.CORBA.portable.ObjectImpl;
|
|
import org.omg.CosNaming.BindingIteratorHolder;
|
|
import org.omg.CosNaming.BindingListHolder;
|
|
import org.omg.CosNaming.NameComponent;
|
|
import org.omg.CosNaming.NamingContext;
|
|
import org.omg.CosNaming.NamingContextExt;
|
|
import org.omg.CosNaming.NamingContextExtHelper;
|
|
import org.omg.CosNaming.NamingContextHelper;
|
|
import org.omg.CosNaming._NamingContextExtStub;
|
|
import org.omg.CosNaming._NamingContextStub;
|
|
import org.omg.CosNaming.NamingContextPackage.AlreadyBound;
|
|
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
|
|
import org.omg.CosNaming.NamingContextPackage.InvalidName;
|
|
import org.omg.CosNaming.NamingContextPackage.NotFound;
|
|
|
|
/**
|
|
* The context to represent the corba naming service. Being the naming service,
|
|
* the returned context supports creating the subcontexts, forwarding this task
|
|
* to the existing naming service. When listing bindings, it uses the
|
|
* {@link Context#BATCHSIZE} property to determine, how many bindings should
|
|
* be returned at once (the process is transparend)
|
|
*
|
|
* @author Audrius Meskauskas (audriusa@Bioinformatics.org)
|
|
*/
|
|
public class ContextContinuation implements Context
|
|
{
|
|
/**
|
|
* This number of bindings will be requested from the naming server at once,
|
|
* while the subsequent bindings will be requested via binding iterator one by
|
|
* one. Use {@link Context#BATCHSIZE} to override the value of this constant.
|
|
*/
|
|
public int DEFAULT_BATCH_SIZE = 20;
|
|
|
|
/**
|
|
* The actual CORBA naming service.
|
|
*/
|
|
NamingContextExt service;
|
|
|
|
/**
|
|
* The object request broker, used to access the naming service. This field
|
|
* is only initialised when the context is constructed from the URL.
|
|
*/
|
|
ORB orb;
|
|
|
|
/**
|
|
* The properties.
|
|
*/
|
|
Hashtable properties;
|
|
|
|
/**
|
|
* The parent factory.
|
|
*/
|
|
GiopNamingServiceFactory factory;
|
|
|
|
/**
|
|
* The name transformer to obtain the name from its string representation. The
|
|
* to_name method of the naming service is avoided as it may be remote and
|
|
* hence expensive. The conversion rules are standard and cannot be service
|
|
* specific.
|
|
*/
|
|
static NameTransformer transformer = new NameTransformer();
|
|
|
|
/**
|
|
* The batch size for list operations - how many to return at once.
|
|
*/
|
|
public final int howMany;
|
|
|
|
/**
|
|
* Creates a new naming context that uses naming service, represented by the
|
|
* given CORBA object.
|
|
*
|
|
* @param nsObject
|
|
* the naming service object. It must be possible to narrow it into
|
|
* the NamingContextExt.
|
|
* @param props
|
|
* the environment table.
|
|
* @param anOrb
|
|
* the associated ORB. This reference is used during cleanup.
|
|
* @param aFactory
|
|
* parent factory. This reference is used during cleanup.
|
|
*/
|
|
public ContextContinuation(org.omg.CORBA.Object nsObject,
|
|
Hashtable props, ORB anOrb,
|
|
GiopNamingServiceFactory aFactory)
|
|
{
|
|
factory = aFactory;
|
|
orb = anOrb;
|
|
|
|
Delegate delegate = ((ObjectImpl) nsObject)._get_delegate();
|
|
|
|
// If the IOR provides the IDL ID, we can check if our name
|
|
// service is old NamingContext or new NamingContextExt.
|
|
// Not all forms of the URL always provide the IDL id.
|
|
if (!nsObject._is_a(NamingContextExtHelper.id())
|
|
&& nsObject._is_a(NamingContextHelper.id()))
|
|
{
|
|
// We are surely working with the old version.
|
|
_NamingContextStub stub = new _NamingContextStub();
|
|
stub._set_delegate(delegate);
|
|
// The Ext object will add the necessary extensions.
|
|
service = new Ext(stub);
|
|
}
|
|
else
|
|
{
|
|
// We expecte the service to be the NamingContextExt (this is true
|
|
// for both Sun's and our implementations). There is no easy way
|
|
// to check the version.
|
|
_NamingContextExtStub stub = new _NamingContextExtStub();
|
|
stub._set_delegate(delegate);
|
|
service = stub;
|
|
}
|
|
properties = props;
|
|
howMany = getBatchSize();
|
|
}
|
|
|
|
/**
|
|
* Give the specified name for the specified object. The passed name must not
|
|
* be already bound to some other object. The components of the name are
|
|
* mapped into the components of the CORBA name.
|
|
*
|
|
* @param name
|
|
* the name that will be given to the object (in the scope of this
|
|
* context).
|
|
* @param obj
|
|
* the object being named.
|
|
* @throws NameAlreadyBoundException
|
|
* if this name is already used to name some object.
|
|
* @throws InvalidAttributesException
|
|
* if the object does not supply all required attributes.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void bind(Name name, Object obj) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj;
|
|
service.bind(toGiop(name), object);
|
|
}
|
|
catch (ClassCastException e)
|
|
{
|
|
throw new NamingException(org.omg.CORBA.Object.class + " required ");
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (AlreadyBound e)
|
|
{
|
|
throw new NameAlreadyBoundException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Give the specified name for the specified object. The passed name must not
|
|
* be already bound to some other object.
|
|
*
|
|
* @param name
|
|
* the name that will be given to the object (in the scope of this
|
|
* context).
|
|
* @param obj
|
|
* the object being named.
|
|
* @throws NameAlreadyBoundException
|
|
* if this name is already used to name some object.
|
|
* @throws InvalidAttributesException
|
|
* if the object does not supply all required attributes.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void bind(String name, Object obj) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj;
|
|
service.bind(transformer.toName(name), object);
|
|
}
|
|
catch (ClassCastException e)
|
|
{
|
|
throw new NamingException(org.omg.CORBA.Object.class + " required ");
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (AlreadyBound e)
|
|
{
|
|
throw new NameAlreadyBoundException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Releases all resources, associated with this context. The close() method
|
|
* can be called several times, but after it has been once invoked, it is not
|
|
* allowed to call any other method of this context. This method destroys
|
|
* the ORB, if we have one.
|
|
*
|
|
* @throws NamingException
|
|
*/
|
|
public void close() throws NamingException
|
|
{
|
|
if (orb != null && factory !=null)
|
|
{
|
|
factory.checkIfReferenced(orb);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Not supported.
|
|
*/
|
|
public Name composeName(Name name, Name prefix) throws NamingException
|
|
{
|
|
throw new OperationNotSupportedException();
|
|
}
|
|
|
|
/**
|
|
* Not supported
|
|
*/
|
|
public String composeName(String name1, String name2) throws NamingException
|
|
{
|
|
throw new OperationNotSupportedException();
|
|
}
|
|
|
|
/**
|
|
* Creates the new naming subcontext and binds it to the current (this)
|
|
* context. The returned object will wrap around the newly created CORBA
|
|
* subcontext
|
|
*
|
|
* @param subContext
|
|
* the name of the new context being created
|
|
* @return the newly created context, bound to the instance of the context on
|
|
* that the method has been called
|
|
* @throws NameAlreadyBoundException
|
|
* if this name is already bound
|
|
* @throws InvalidAttributesException
|
|
* if the creation of the new context requires the missing mandatory
|
|
* attributes
|
|
* @throws NamingException
|
|
*/
|
|
public Context createSubcontext(Name subContext) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object subcontext = service.bind_new_context(
|
|
toGiop(subContext));
|
|
Hashtable clonedProps = new Hashtable();
|
|
clonedProps.putAll(properties);
|
|
|
|
// Nulls are passed both for orb and factory, as the child contexts
|
|
// need not to do any cleanup.
|
|
return new ContextContinuation(subcontext, clonedProps, null, null);
|
|
}
|
|
catch (AlreadyBound e)
|
|
{
|
|
throw new NameAlreadyBoundException();
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new NamingException(ex.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates the new naming subcontext and binds it to the current (this)
|
|
* context. The returned object will wrap around the newly created CORBA
|
|
* subcontext
|
|
*
|
|
* @param subContext
|
|
* the name of the new context being created
|
|
* @return the newly created context, bound to the instance of the context on
|
|
* that the method has been called
|
|
* @throws NameAlreadyBoundException
|
|
* if this name is already bound
|
|
* @throws InvalidAttributesException
|
|
* if the creation of the new context requires the missing mandatory
|
|
* attributes
|
|
* @throws NamingException
|
|
*/
|
|
public Context createSubcontext(String subContext) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object subcontext =
|
|
service.bind_new_context(transformer.toName(subContext));
|
|
Hashtable clonedProps = new Hashtable();
|
|
clonedProps.putAll(properties);
|
|
|
|
// Nulls are passed both for orb and factory, as the child contexts
|
|
// need not to do any cleanup.
|
|
return new ContextContinuation(subcontext, clonedProps, null,
|
|
null);
|
|
}
|
|
catch (AlreadyBound e)
|
|
{
|
|
throw new NameAlreadyBoundException(subContext);
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException(subContext);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new NamingException(ex.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the naming subcontext from this naming context. Returns without
|
|
* action if such subcontext does not exist. The context being destroyed must
|
|
* be empty.
|
|
*
|
|
* @param subContext
|
|
* the name of the subcontext beig removed.
|
|
* @throws ContextNotEmptyException
|
|
* if the named context is not empty.
|
|
* @throws NamingException
|
|
*/
|
|
public void destroySubcontext(Name subContext) throws NamingException
|
|
{
|
|
unbind(subContext);
|
|
}
|
|
|
|
/**
|
|
* Removes the naming subcontext from this naming context. Returns without
|
|
* action if such subcontext does not exist. The context being destroyed must
|
|
* be empty.
|
|
*
|
|
* @param subContext
|
|
* the name of the subcontext beig removed.
|
|
* @throws ContextNotEmptyException
|
|
* if the named context is not empty.
|
|
* @throws NamingException
|
|
*/
|
|
public void destroySubcontext(String subContext) throws NamingException
|
|
{
|
|
unbind(subContext);
|
|
}
|
|
|
|
/**
|
|
* Returs the full name of this naming context. The returned string is not a
|
|
* JNDI composite name and should not be passed directly to the methods of the
|
|
* naming context. This implementation returns the IOR.
|
|
*
|
|
* @return the full name of this naming context, in its own namespace.
|
|
* @throws OperationNotSupportedException
|
|
* if the naming system, represented by this context, does not
|
|
* support the notation of the full name.
|
|
* @throws NamingException
|
|
*/
|
|
public String getNameInNamespace() throws NamingException
|
|
{
|
|
if (orb != null)
|
|
return orb.object_to_string(service);
|
|
else
|
|
{
|
|
try
|
|
{
|
|
ObjectImpl impl = (ObjectImpl) service;
|
|
return impl._orb().object_to_string(impl);
|
|
}
|
|
catch (ClassCastException e)
|
|
{
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Not supported.
|
|
*/
|
|
public NameParser getNameParser(Name name) throws NamingException
|
|
{
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Not supported.
|
|
*/
|
|
public NameParser getNameParser(String name) throws NamingException
|
|
{
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Creates and returns the enumeration over the name bindings that are present
|
|
* the given subcontext. The enumeration elements have the type of
|
|
* {@link NameClassPair}, providing also information about the class of the
|
|
* bound object. The behaviour in the case if the bindings are added or
|
|
* removed later is not defined. The contents of the subcontexts are not
|
|
* included.
|
|
*
|
|
* @param name
|
|
* the name of the subcontext
|
|
* @return the enumeration over the names, known for the given subcontext.
|
|
* @throws NamingException
|
|
*/
|
|
public NamingEnumeration list(Name name) throws NamingException
|
|
{
|
|
BindingIteratorHolder bi = new BindingIteratorHolder();
|
|
BindingListHolder bl = new BindingListHolder();
|
|
|
|
NamingContext subcontext;
|
|
|
|
if (name.size() == 0)
|
|
subcontext = service;
|
|
else
|
|
{
|
|
try
|
|
{
|
|
subcontext = (NamingContextHelper.narrow(service.resolve(toGiop(name))));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
|
|
}
|
|
|
|
subcontext.list(howMany, bl, bi);
|
|
|
|
return new ListEnumeration(bl, bi, howMany);
|
|
}
|
|
|
|
/**
|
|
* Creates and returns the enumeration over the name bindings that are present
|
|
* the given subcontext. The enumeration elements have the type of
|
|
* {@link NameClassPair}, providing also information about the class of the
|
|
* bound object. The behaviour in the case if the bindings are added or
|
|
* removed later is not defined. The contents of the subcontexts are not
|
|
* included.
|
|
*
|
|
* @param name
|
|
* the name of the subcontext
|
|
* @return the enumeration over the names, known for the given subcontext.
|
|
* @throws NamingException
|
|
*/
|
|
public NamingEnumeration list(String name) throws NamingException
|
|
{
|
|
BindingIteratorHolder bi = new BindingIteratorHolder();
|
|
BindingListHolder bl = new BindingListHolder();
|
|
|
|
NamingContext subcontext;
|
|
|
|
if (name.length() == 0)
|
|
subcontext = service;
|
|
else
|
|
{
|
|
try
|
|
{
|
|
subcontext = (NamingContextHelper.narrow(service.resolve_str(name)));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
|
|
}
|
|
|
|
subcontext.list(howMany, bl, bi);
|
|
|
|
return new ListEnumeration(bl, bi, howMany);
|
|
}
|
|
|
|
/**
|
|
* Creates and returns the enumeration over the name - object bindings that
|
|
* are present the given subcontext. The enumeration elements have the type of
|
|
* {@link Binding}, providing also information about the class of the bound
|
|
* object. The behaviour in the case if the bindings are added or removed
|
|
* later is not defined. The contents of the subcontexts are not included.
|
|
*
|
|
* @param name
|
|
* the name of the subcontext
|
|
* @return the enumeration over the names, known for the given subcontext.
|
|
* @throws NamingException
|
|
*/
|
|
public NamingEnumeration listBindings(Name name) throws NamingException
|
|
{
|
|
BindingIteratorHolder bi = new BindingIteratorHolder();
|
|
BindingListHolder bl = new BindingListHolder();
|
|
|
|
NamingContext subcontext;
|
|
|
|
if (name.size() == 0)
|
|
subcontext = service;
|
|
else
|
|
{
|
|
try
|
|
{
|
|
subcontext = (NamingContextHelper.narrow(service.resolve(toGiop(name))));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
subcontext.list(howMany, bl, bi);
|
|
|
|
return new ListBindingsEnumeration(bl, bi, howMany, subcontext);
|
|
}
|
|
|
|
/**
|
|
* Creates and returns the enumeration over the name - object bindings that
|
|
* are present the given subcontext. The enumeration elements have the type of
|
|
* {@link Binding}, providing also information about the class of the bound
|
|
* object. The behaviour in the case if the bindings are added or removed
|
|
* later is not defined. The contents of the subcontexts are not included.
|
|
*
|
|
* @param name
|
|
* the name of the subcontext
|
|
* @return the enumeration over the names, known for the given subcontext.
|
|
* @throws NamingException
|
|
*/
|
|
public NamingEnumeration listBindings(String name) throws NamingException
|
|
{
|
|
BindingIteratorHolder bi = new BindingIteratorHolder();
|
|
BindingListHolder bl = new BindingListHolder();
|
|
|
|
NamingContext subcontext;
|
|
|
|
if (name.length() == 0)
|
|
subcontext = service;
|
|
else
|
|
{
|
|
try
|
|
{
|
|
subcontext = (NamingContextHelper.narrow(service.resolve_str(name)));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
|
|
}
|
|
|
|
subcontext.list(howMany, bl, bi);
|
|
|
|
return new ListBindingsEnumeration(bl, bi, howMany, subcontext);
|
|
}
|
|
|
|
/**
|
|
* Gets the previously named object by name. If the passed name is empty, the
|
|
* method should return a cloned instance of this naming context.
|
|
*
|
|
* @param name
|
|
* the name of the object being searched in this context
|
|
* @return the named object
|
|
* @throws NameNotFountException
|
|
* if the name is not found
|
|
*/
|
|
public Object lookup(Name name) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
return service.resolve(toGiop(name));
|
|
}
|
|
catch (NotFound e)
|
|
{
|
|
throw new NameNotFoundException();
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the previously named object by name. If the passed name is empty, the
|
|
* method should return a cloned instance of this naming context.
|
|
*
|
|
* @param name
|
|
* the name of the object being searched in this context
|
|
* @return the named object
|
|
* @throws NamingException
|
|
* if the naming fails.
|
|
*/
|
|
public Object lookup(String name) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
return service.resolve_str(name);
|
|
}
|
|
catch (NotFound e)
|
|
{
|
|
throw new NameNotFoundException();
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Not supported.
|
|
*/
|
|
public Object lookupLink(Name name) throws NamingException
|
|
{
|
|
throw new OperationNotSupportedException();
|
|
}
|
|
|
|
/**
|
|
* Not supported.
|
|
*/
|
|
public Object lookupLink(String name) throws NamingException
|
|
{
|
|
throw new OperationNotSupportedException();
|
|
}
|
|
|
|
/**
|
|
* Give the specified name for the specified object. Unlike bind, this method
|
|
* silently replaces the existing binding for this name, if one exists.
|
|
*
|
|
* @param name
|
|
* the name that will be given to the object (in the scope of this
|
|
* context).
|
|
* @param obj
|
|
* the object being named.
|
|
* @throws InvalidAttributesException
|
|
* if the object does not supply all required attributes.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void rebind(Name name, Object obj) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj;
|
|
service.rebind(toGiop(name), object);
|
|
}
|
|
catch (ClassCastException e)
|
|
{
|
|
throw new NamingException(org.omg.CORBA.Object.class + " required ");
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Give the specified name for the specified object. Unlike bind, this method
|
|
* silently replaces the existing binding for this name, if one exists.
|
|
*
|
|
* @param name
|
|
* the name that will be given to the object (in the scope of this
|
|
* context).
|
|
* @param obj
|
|
* the object being named.
|
|
* @throws InvalidAttributesException
|
|
* if the object does not supply all required attributes.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void rebind(String name, Object obj) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj;
|
|
service.rebind(transformer.toName(name), object);
|
|
}
|
|
catch (ClassCastException e)
|
|
{
|
|
throw new NamingException(org.omg.CORBA.Object.class + " required ");
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new NamingException(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renames the existing binding, removing the existing and giving the new name
|
|
* for the same object.
|
|
*
|
|
* @param oldName
|
|
* the existing name of the known object
|
|
* @param newName
|
|
* the new name of the same object
|
|
* @throws NameNotFoundException
|
|
* if the oldName is unknown for this context
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void rename(Name oldName, Name newName) throws NamingException
|
|
{
|
|
Object object = lookup(oldName);
|
|
unbind(oldName);
|
|
bind(newName, object);
|
|
}
|
|
|
|
/**
|
|
* Renames the existing binding, removing the existing and giving the new name
|
|
* for the same object.
|
|
*
|
|
* @param oldName
|
|
* the existing name of the known object
|
|
* @param newName
|
|
* the new name of the same object
|
|
* @throws NameNotFoundException
|
|
* if the oldName is unknown for this context
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void rename(String oldName, String newName) throws NamingException
|
|
{
|
|
Object object = lookup(oldName);
|
|
unbind(oldName);
|
|
bind(newName, object);
|
|
}
|
|
|
|
/**
|
|
* Removes the name - object mapping from the current context. This method
|
|
* returns without action if the name is not bound to an object in the
|
|
* terminal context, but throws {@link NameNotFoundException} if one of the
|
|
* intermadiate contexts does not exist.
|
|
*
|
|
* @param name
|
|
* the name to be removed
|
|
* @throws NameNotFoundException
|
|
* if one of the intermediate naming contexts does not exist. Will
|
|
* not be thrown if just the terminal binding is missing.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void unbind(Name name) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
service.unbind(toGiop(name));
|
|
}
|
|
catch (NotFound e)
|
|
{
|
|
throw new NameNotFoundException();
|
|
}
|
|
catch (CannotProceed e)
|
|
{
|
|
throw new ContextNotEmptyException();
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the name - object mapping from the current context. This method
|
|
* returns without action if the name is not bound to an object in the
|
|
* terminal context, but throws {@link NameNotFoundException} if one of the
|
|
* intermadiate contexts does not exist.
|
|
*
|
|
* @param name
|
|
* the name to be removed
|
|
* @throws NameNotFoundException
|
|
* if one of the intermediate naming contexts does not exist. Will
|
|
* not be thrown if just the terminal binding is missing.
|
|
* @throws NamingException
|
|
* if the naming operation has failed due other reasons.
|
|
*/
|
|
public void unbind(String name) throws NamingException
|
|
{
|
|
try
|
|
{
|
|
service.unbind(transformer.toName(name));
|
|
}
|
|
catch (NotFound e)
|
|
{
|
|
throw new NameNotFoundException(name);
|
|
}
|
|
catch (CannotProceed e)
|
|
{
|
|
throw new ContextNotEmptyException(name);
|
|
}
|
|
catch (InvalidName e)
|
|
{
|
|
throw new InvalidNameException(name);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add new environment property to the environment of this context. Both name
|
|
* and value of the new property must not be null. If the property is already
|
|
* defined, is current value is replaced by the propVal.
|
|
*
|
|
* @param key
|
|
* the name of the new property
|
|
* @param value
|
|
* the value of the new property
|
|
* @return the previous value of this property or null if the property has not
|
|
* been previously defined
|
|
* @throws NamingException
|
|
*/
|
|
public Object addToEnvironment(String key, Object value)
|
|
throws NamingException
|
|
{
|
|
if (key == null || value == null)
|
|
throw new NullPointerException();
|
|
return properties.put(key, value);
|
|
}
|
|
|
|
/**
|
|
* Returns the environment, associated with this naming context. The returned
|
|
* table should never be modified by the caller. Use {@link #addToEnvironment}
|
|
* and {@link #removeFromEnvironment} to modify the environement, if needed.
|
|
*
|
|
* @return the table, representing the environment of this context
|
|
* @throws NamingException
|
|
*/
|
|
public Hashtable getEnvironment() throws NamingException
|
|
{
|
|
return properties;
|
|
}
|
|
|
|
/**
|
|
* Removes the property with the given name from the environment. Returns
|
|
* without action if this property is not defined.
|
|
*
|
|
* @param propName
|
|
* the name of the property being removed.
|
|
* @return the value of the property that has been removed or null if the
|
|
* property was not defined.
|
|
* @throws NamingException
|
|
*/
|
|
public Object removeFromEnvironment(String propName) throws NamingException
|
|
{
|
|
return properties.remove(propName);
|
|
}
|
|
|
|
/**
|
|
* Convert the {@link Name} into array of the name components, required to the
|
|
* CORBA naming service. First the string representation is obtained, then
|
|
* it is converted using parsing rules of the CORBA name.
|
|
*
|
|
* @param name
|
|
* then name to convert
|
|
* @return the converted array of components.
|
|
*/
|
|
public NameComponent[] toGiop(Name name) throws InvalidName
|
|
{
|
|
return transformer.toName(name.toString());
|
|
}
|
|
|
|
/**
|
|
* Get the batch size from the environment properties. The batch size is used
|
|
* for listing operations.
|
|
*
|
|
* @return the batch size, or some default value if not specified.
|
|
*/
|
|
public int getBatchSize()
|
|
{
|
|
int batchSize = DEFAULT_BATCH_SIZE;
|
|
Object bs = properties.get(Context.BATCHSIZE);
|
|
if (bs != null)
|
|
{
|
|
try
|
|
{
|
|
int b = Integer.parseInt(bs.toString());
|
|
if (b >= 0)
|
|
batchSize = b;
|
|
}
|
|
catch (NumberFormatException e)
|
|
{
|
|
// OK, use default value.
|
|
}
|
|
}
|
|
return batchSize;
|
|
}
|
|
|
|
|
|
}
|