| /* GiopNamingServiceURLContext.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 GiopNamingServiceURLContext extends CorbalocParser 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 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 props | |
| * the environment table. | |
| * @param aFactory | |
| * parent factory. This reference is used during cleanup. | |
| * @param anOrb | |
| * the associated ORB. This reference is used during cleanup. | |
| */ | |
| public GiopNamingServiceURLContext(Hashtable props, | |
| GiopNamingServiceFactory aFactory, | |
| ORB anOrb) | |
| { | |
| factory = aFactory; | |
| orb = anOrb; | |
| properties = props; | |
| howMany = getBatchSize(); | |
| } | |
| public NamingContextExt getService(String address) | |
| { | |
| org.omg.CORBA.Object nsObject = orb.string_to_object(address); | |
| 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. | |
| return 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); | |
| return stub; | |
| } | |
| } | |
| /** | |
| * Split the corbaname name into the address of the naming service (first | |
| * part) and the name of the object in the naming service (second part) | |
| */ | |
| public String[] split(String corbaloc) throws InvalidNameException | |
| { | |
| if (corbaloc.endsWith("#")) | |
| corbaloc = corbaloc.substring(0, corbaloc.length() - 1); | |
| // No name part - parse as corbaname. | |
| if (corbaloc.indexOf('#') < 0) | |
| { | |
| if (!corbaloc.regionMatches(true, 0, pxCORBANAME, 0, | |
| pxCORBANAME.length())) | |
| throw new InvalidNameException(corbaloc + " must start with " | |
| + pxCORBANAME); | |
| corbaloc = pxCORBALOC + corbaloc.substring(pxCORBANAME.length()); | |
| return new String[] { corbaloc, "" }; | |
| } | |
| return corbaloc(corbaloc, orb); | |
| } | |
| /** | |
| * 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 | |
| { | |
| bind(name.toString(), obj); | |
| } | |
| /** | |
| * 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 | |
| { | |
| String[] n = split(name); | |
| org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj; | |
| getService(n[0]).bind(transformer.toName(n[1]), 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 | |
| { | |
| return createSubcontext(subContext.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 | |
| { | |
| String[] n = split(subContext); | |
| org.omg.CORBA.Object subcontext = getService(n[0]).bind_new_context( | |
| transformer.toName(n[1])); | |
| 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 empty string. | |
| */ | |
| public String getNameInNamespace() throws NamingException | |
| { | |
| return ""; | |
| } | |
| /** | |
| * 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 | |
| { | |
| return list(name.toString()); | |
| } | |
| /** | |
| * 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; | |
| String [] n = split(name); | |
| NamingContextExt service = getService(n[0]); | |
| if (n[1].length() == 0) | |
| subcontext = service; | |
| else | |
| { | |
| try | |
| { | |
| subcontext = (NamingContextHelper.narrow(service.resolve_str(n[1]))); | |
| } | |
| 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 | |
| { | |
| return listBindings(name.toString()); | |
| } | |
| /** | |
| * 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; | |
| String [] n = split(name); | |
| NamingContextExt service = getService(n[0]); | |
| if (n[1].length() == 0) | |
| subcontext = service; | |
| else | |
| { | |
| try | |
| { | |
| subcontext = (NamingContextHelper.narrow(service.resolve_str(n[1]))); | |
| } | |
| 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 NameNotFoundException | |
| * if the name is not found | |
| */ | |
| public Object lookup(Name name) throws NamingException | |
| { | |
| return lookup(name.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 | |
| { | |
| String [] n = split(name); | |
| NamingContextExt service = getService(n[0]); | |
| return service.resolve_str(n[1]); | |
| } | |
| 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 | |
| { | |
| rebind(name.toString(), obj); | |
| } | |
| /** | |
| * 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 | |
| { | |
| String[] n = split(name); | |
| NamingContextExt service = getService(n[0]); | |
| org.omg.CORBA.Object object = (org.omg.CORBA.Object) obj; | |
| service.rebind(transformer.toName(n[1]), 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 | |
| { | |
| unbind(name.toString()); | |
| } | |
| /** | |
| * 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 | |
| { | |
| String[] n = split(name); | |
| NamingContextExt service = getService(n[0]); | |
| service.unbind(transformer.toName(n[1])); | |
| } | |
| 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; | |
| } | |
| } |