tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cos...@apache.org
Subject cvs commit: jakarta-tomcat-connectors/naming/src/org/apache/naming/core BaseContext.java
Date Tue, 05 Nov 2002 19:06:59 GMT
costin      2002/11/05 11:06:59

  Modified:    naming/src/org/apache/naming/core BaseContext.java
  Log:
  Similar changes for the base context
  
  Revision  Changes    Path
  1.2       +226 -254  jakarta-tomcat-connectors/naming/src/org/apache/naming/core/BaseContext.java
  
  Index: BaseContext.java
  ===================================================================
  RCS file: /home/cvs/jakarta-tomcat-connectors/naming/src/org/apache/naming/core/BaseContext.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- BaseContext.java	17 Oct 2002 16:44:14 -0000	1.1
  +++ BaseContext.java	5 Nov 2002 19:06:59 -0000	1.2
  @@ -3,7 +3,7 @@
    *
    * The Apache Software License, Version 1.1
    *
  - * Copyright (c) 1999 The Apache Software Foundation.  All rights 
  + * Copyright (c) 1999 The Apache Software Foundation.  All rights
    * reserved.
    *
    * Redistribution and use in source and binary forms, with or without
  @@ -11,7 +11,7 @@
    * are met:
    *
    * 1. Redistributions of source code must retain the above copyright
  - *    notice, this list of conditions and the following disclaimer. 
  + *    notice, this list of conditions and the following disclaimer.
    *
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in
  @@ -19,15 +19,15 @@
    *    distribution.
    *
    * 3. The end-user documentation included with the redistribution, if
  - *    any, must include the following acknowlegement:  
  - *       "This product includes software developed by the 
  + *    any, must include the following acknowlegement:
  + *       "This product includes software developed by the
    *        Apache Software Foundation (http://www.apache.org/)."
    *    Alternately, this acknowlegement may appear in the software itself,
    *    if and wherever such third-party acknowlegements normally appear.
    *
    * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
    *    Foundation" must not be used to endorse or promote products derived
  - *    from this software without prior written permission. For written 
  + *    from this software without prior written permission. For written
    *    permission, please contact apache@apache.org.
    *
    * 5. Products derived from this software may not be called "Apache"
  @@ -55,7 +55,7 @@
    *
    * [Additional notices, if required by prior licensing conditions]
    *
  - */ 
  + */
   
   
   package org.apache.naming.core;
  @@ -67,6 +67,7 @@
   import javax.naming.directory.Attribute;
   import javax.naming.directory.ModificationItem;
   import javax.naming.directory.SearchControls;
  +
   import org.apache.tomcat.util.res.StringManager;
   
   // Based on a merge of various catalina naming contexts
  @@ -99,334 +100,316 @@
       }
   
   
  -    // -------------------- Context impl -------------------- 
  -    
  +    // -------------------- Context impl --------------------
  +
       /**
  -     * Retrieves the named object. If name is empty, returns a new instance 
  -     * of this context (which represents the same naming context as this 
  -     * context, but its environment may be modified independently and it may 
  +     * Retrieves the named object. If name is empty, returns a new instance
  +     * of this context (which represents the same naming context as this
  +     * context, but its environment may be modified independently and it may
        * be accessed concurrently).
  -     * 
  +     *
        * @param name the name of the object to look up
        * @return the object bound to name
        * @exception NamingException if a naming exception is encountered
        */
       public Object lookup(Name name)
  -        throws NamingException
  -    {
  -        return lookup(name, true );
  +            throws NamingException {
  +        return lookup(name, true);
       }
   
       /**
        * Retrieves the named object.
  -     * 
  +     *
        * @param name the name of the object to look up
        * @return the object bound to name
        * @exception NamingException if a naming exception is encountered
        */
       public Object lookup(String name)
  -        throws NamingException
  -    {
  -        return lookup( string2Name(name), true);
  +            throws NamingException {
  +        return lookup(string2Name(name), true);
       }
   
   
       /**
  -     * Binds a name to an object. All intermediate contexts and the target 
  -     * context (that named by all but terminal atomic component of the name) 
  +     * Binds a name to an object. All intermediate contexts and the target
  +     * context (that named by all but terminal atomic component of the name)
        * must already exist.
  -     * 
  +     *
        * @param name the name to bind; may not be empty
        * @param obj the object to bind; possibly null
        * @exception NameAlreadyBoundException if name is already bound
  -     * @exception InvalidAttributesException if object did not supply all 
  +     * @exception InvalidAttributesException if object did not supply all
        * mandatory attributes
        * @exception NamingException if a naming exception is encountered
        */
       public void bind(Name name, Object obj)
  -        throws NamingException
  -    {
  +            throws NamingException {
           bind(name, obj, null, false);
       }
   
   
       /**
        * Binds a name to an object.
  -     * 
  +     *
        * @param name the name to bind; may not be empty
        * @param obj the object to bind; possibly null
        * @exception NameAlreadyBoundException if name is already bound
  -     * @exception InvalidAttributesException if object did not supply all 
  +     * @exception InvalidAttributesException if object did not supply all
        * mandatory attributes
        * @exception NamingException if a naming exception is encountered
        */
       public void bind(String name, Object obj)
  -        throws NamingException
  -    {
  +            throws NamingException {
           bind(string2Name(name), obj, null, false);
       }
   
   
       /**
  -     * Binds a name to an object, overwriting any existing binding. All 
  -     * intermediate contexts and the target context (that named by all but 
  +     * Binds a name to an object, overwriting any existing binding. All
  +     * intermediate contexts and the target context (that named by all but
        * terminal atomic component of the name) must already exist.
        * <p>
  -     * If the object is a DirContext, any existing attributes associated with 
  -     * the name are replaced with those of the object. Otherwise, any 
  +     * If the object is a DirContext, any existing attributes associated with
  +     * the name are replaced with those of the object. Otherwise, any
        * existing attributes associated with the name remain unchanged.
  -     * 
  +     *
        * @param name the name to bind; may not be empty
        * @param obj the object to bind; possibly null
  -     * @exception InvalidAttributesException if object did not supply all 
  +     * @exception InvalidAttributesException if object did not supply all
        * mandatory attributes
        * @exception NamingException if a naming exception is encountered
        */
       public void rebind(Name name, Object obj)
  -        throws NamingException
  -    {
  +            throws NamingException {
           bind(name, obj, null, true);
       }
   
   
       /**
        * Binds a name to an object, overwriting any existing binding.
  -     * 
  +     *
        * @param name the name to bind; may not be empty
        * @param obj the object to bind; possibly null
  -     * @exception InvalidAttributesException if object did not supply all 
  +     * @exception InvalidAttributesException if object did not supply all
        * mandatory attributes
        * @exception NamingException if a naming exception is encountered
        */
       public void rebind(String name, Object obj)
  -        throws NamingException
  -    {
  +            throws NamingException {
           bind(string2Name(name), obj, null, true);
       }
   
   
       /**
  -     * Unbinds the named object. Removes the terminal atomic name in name 
  -     * from the target context--that named by all but the terminal atomic 
  +     * Unbinds the named object. Removes the terminal atomic name in name
  +     * from the target context--that named by all but the terminal atomic
        * part of name.
        * <p>
  -     * This method is idempotent. It succeeds even if the terminal atomic 
  -     * name is not bound in the target context, but throws 
  -     * NameNotFoundException if any of the intermediate contexts do not exist. 
  -     * 
  +     * This method is idempotent. It succeeds even if the terminal atomic
  +     * name is not bound in the target context, but throws
  +     * NameNotFoundException if any of the intermediate contexts do not exist.
  +     *
        * @param name the name to bind; may not be empty
  -     * @exception NameNotFoundException if an intermediate context does not 
  +     * @exception NameNotFoundException if an intermediate context does not
        * exist
        * @exception NamingException if a naming exception is encountered
        */
       public void unbind(Name name)
  -        throws NamingException
  -    {
  -        unbind( name, false );
  +            throws NamingException {
  +        unbind(name, false);
       }
  -    
  +
       public void unbind(String name)
  -        throws NamingException
  -    {
  -        unbind( string2Name( name ), false);
  +            throws NamingException {
  +        unbind(string2Name(name), false);
       }
   
   
       /**
  -     * Binds a new name to the object bound to an old name, and unbinds the 
  -     * old name. Both names are relative to this context. Any attributes 
  -     * associated with the old name become associated with the new name. 
  +     * Binds a new name to the object bound to an old name, and unbinds the
  +     * old name. Both names are relative to this context. Any attributes
  +     * associated with the old name become associated with the new name.
        * Intermediate contexts of the old name are not changed.
  -     * 
  +     *
        * @param oldName the name of the existing binding; may not be empty
        * @param newName the name of the new binding; may not be empty
        * @exception NameAlreadyBoundException if newName is already bound
        * @exception NamingException if a naming exception is encountered
        */
  -    public  void rename(String oldName, String newName)
  -        throws NamingException
  -    {
  -        rename( string2Name( oldName ), string2Name( newName ));
  +    public void rename(String oldName, String newName)
  +            throws NamingException {
  +        rename(string2Name(oldName), string2Name(newName));
       }
   
   
       /**
  -     * Enumerates the names bound in the named context, along with the class 
  -     * names of objects bound to them. The contents of any subcontexts are 
  +     * Enumerates the names bound in the named context, along with the class
  +     * names of objects bound to them. The contents of any subcontexts are
        * not included.
        * <p>
  -     * If a binding is added to or removed from this context, its effect on 
  +     * If a binding is added to or removed from this context, its effect on
        * an enumeration previously returned is undefined.
  -     * 
  +     *
        * @param name the name of the context to list
  -     * @return an enumeration of the names and class names of the bindings in 
  +     * @return an enumeration of the names and class names of the bindings in
        * this context. Each element of the enumeration is of type NameClassPair.
        * @exception NamingException if a naming exception is encountered
        */
       public NamingEnumeration list(String name)
  -        throws NamingException
  -    {
  +            throws NamingException {
           return list(string2Name(name));
       }
   
       public NamingEnumeration list(Name name)
  -        throws NamingException
  -    {
  -        throw new OperationNotSupportedException("list");
  +            throws NamingException {
  +        return new NamingContextEnumeration(super.getChildren(), this, false);
       }
   
   
       /**
  -     * Enumerates the names bound in the named context, along with the 
  -     * objects bound to them. The contents of any subcontexts are not 
  +     * Enumerates the names bound in the named context, along with the
  +     * objects bound to them. The contents of any subcontexts are not
        * included.
        * <p>
  -     * If a binding is added to or removed from this context, its effect on 
  +     * If a binding is added to or removed from this context, its effect on
        * an enumeration previously returned is undefined.
  -     * 
  +     *
        * @param name the name of the context to list
  -     * @return an enumeration of the bindings in this context. 
  +     * @return an enumeration of the bindings in this context.
        * Each element of the enumeration is of type Binding.
        * @exception NamingException if a naming exception is encountered
        */
       public NamingEnumeration listBindings(Name name)
  -        throws NamingException
  -    {
  -        throw new OperationNotSupportedException( "listBindings" );
  +            throws NamingException {
  +        return new NamingContextEnumeration(super.getChildren(), this, true);
       }
   
       public NamingEnumeration listBindings(String name)
  -        throws NamingException
  -    {
  -        return listBindings( string2Name( name ));
  +            throws NamingException {
  +        return listBindings(string2Name(name));
       }
   
   
       /**
  -     * Destroys the named context and removes it from the namespace. Any 
  -     * attributes associated with the name are also removed. Intermediate 
  +     * Destroys the named context and removes it from the namespace. Any
  +     * attributes associated with the name are also removed. Intermediate
        * contexts are not destroyed.
        * <p>
  -     * This method is idempotent. It succeeds even if the terminal atomic 
  -     * name is not bound in the target context, but throws 
  -     * NameNotFoundException if any of the intermediate contexts do not exist. 
  -     * 
  -     * In a federated naming system, a context from one naming system may be 
  -     * bound to a name in another. One can subsequently look up and perform 
  -     * operations on the foreign context using a composite name. However, an 
  -     * attempt destroy the context using this composite name will fail with 
  -     * NotContextException, because the foreign context is not a "subcontext" 
  -     * of the context in which it is bound. Instead, use unbind() to remove 
  -     * the binding of the foreign context. Destroying the foreign context 
  -     * requires that the destroySubcontext() be performed on a context from 
  +     * This method is idempotent. It succeeds even if the terminal atomic
  +     * name is not bound in the target context, but throws
  +     * NameNotFoundException if any of the intermediate contexts do not exist.
  +     *
  +     * In a federated naming system, a context from one naming system may be
  +     * bound to a name in another. One can subsequently look up and perform
  +     * operations on the foreign context using a composite name. However, an
  +     * attempt destroy the context using this composite name will fail with
  +     * NotContextException, because the foreign context is not a "subcontext"
  +     * of the context in which it is bound. Instead, use unbind() to remove
  +     * the binding of the foreign context. Destroying the foreign context
  +     * requires that the destroySubcontext() be performed on a context from
        * the foreign context's "native" naming system.
  -     * 
  +     *
        * @param name the name of the context to be destroyed; may not be empty
  -     * @exception NameNotFoundException if an intermediate context does not 
  +     * @exception NameNotFoundException if an intermediate context does not
        * exist
  -     * @exception NotContextException if the name is bound but does not name 
  +     * @exception NotContextException if the name is bound but does not name
        * a context, or does not name a context of the appropriate type
        */
       public void destroySubcontext(Name name)
  -        throws NamingException
  -    {
  -        unbind( name, true );
  +            throws NamingException {
  +        unbind(name, true);
       }
   
   
       /**
        * Destroys the named context and removes it from the namespace.
  -     * 
  +     *
        * @param name the name of the context to be destroyed; may not be empty
  -     * @exception NameNotFoundException if an intermediate context does not 
  +     * @exception NameNotFoundException if an intermediate context does not
        * exist
  -     * @exception NotContextException if the name is bound but does not name 
  +     * @exception NotContextException if the name is bound but does not name
        * a context, or does not name a context of the appropriate type
        */
  -    public  void destroySubcontext(String name)
  -        throws NamingException
  -    {
  -        unbind( string2Name( name ), true );
  +    public void destroySubcontext(String name)
  +            throws NamingException {
  +        unbind(string2Name(name), true);
       }
   
   
       /**
  -     * Creates and binds a new context. Creates a new context with the given 
  -     * name and binds it in the target context (that named by all but 
  -     * terminal atomic component of the name). All intermediate contexts and 
  +     * Creates and binds a new context. Creates a new context with the given
  +     * name and binds it in the target context (that named by all but
  +     * terminal atomic component of the name). All intermediate contexts and
        * the target context must already exist.
  -     * 
  +     *
        * @param name the name of the context to create; may not be empty
        * @return the newly created context
        * @exception NameAlreadyBoundException if name is already bound
  -     * @exception InvalidAttributesException if creation of the subcontext 
  +     * @exception InvalidAttributesException if creation of the subcontext
        * requires specification of mandatory attributes
        * @exception NamingException if a naming exception is encountered
        */
       public Context createSubcontext(Name name)
  -        throws NamingException
  -    {
  -        return createSubcontext( name, null );
  +            throws NamingException {
  +        return createSubcontext(name, null);
       }
   
       public Context createSubcontext(String name)
  -        throws NamingException
  -    {
  -        return createSubcontext( string2Name( name ),null);
  +            throws NamingException {
  +        return createSubcontext(string2Name(name), null);
       }
   
   
       /**
  -     * Retrieves the named object, following links except for the terminal 
  -     * atomic component of the name. If the object bound to name is not a 
  +     * Retrieves the named object, following links except for the terminal
  +     * atomic component of the name. If the object bound to name is not a
        * link, returns the object itself.
  -     * 
  +     *
        * @param name the name of the object to look up
  -     * @return the object bound to name, not following the terminal link 
  +     * @return the object bound to name, not following the terminal link
        * (if any).
        * @exception NamingException if a naming exception is encountered
        */
       public Object lookupLink(Name name)
  -        throws NamingException {
  +            throws NamingException {
           return lookup(name, false);
       }
   
   
       /**
  -     * Retrieves the named object, following links except for the terminal 
  +     * Retrieves the named object, following links except for the terminal
        * atomic component of the name.
  -     * 
  +     *
        * @param name the name of the object to look up
  -     * @return the object bound to name, not following the terminal link 
  +     * @return the object bound to name, not following the terminal link
        * (if any).
        * @exception NamingException if a naming exception is encountered
        */
       public Object lookupLink(String name)
  -        throws NamingException
  -    {
  -        return lookupLink( string2Name(name) );
  +            throws NamingException {
  +        return lookupLink(string2Name(name));
       }
   
   
       /**
  -     * Retrieves the parser associated with the named context. In a 
  -     * federation of namespaces, different naming systems will parse names 
  -     * differently. This method allows an application to get a parser for 
  -     * parsing names into their atomic components using the naming convention 
  -     * of a particular naming system. Within any single naming system, 
  -     * NameParser objects returned by this method must be equal (using the 
  +     * Retrieves the parser associated with the named context. In a
  +     * federation of namespaces, different naming systems will parse names
  +     * differently. This method allows an application to get a parser for
  +     * parsing names into their atomic components using the naming convention
  +     * of a particular naming system. Within any single naming system,
  +     * NameParser objects returned by this method must be equal (using the
        * equals() test).
  -     * 
  +     *
        * @param name the name of the context from which to get the parser
  -     * @return a name parser that can parse compound names into their atomic 
  +     * @return a name parser that can parse compound names into their atomic
        * components
        * @exception NamingException if a naming exception is encountered
        */
       public NameParser getNameParser(Name name)
  -        throws NamingException {
  +            throws NamingException {
   
  -	while ((!name.isEmpty()) && (name.get(0).length() == 0))
  -	    name = name.getSuffix(1);
  +        while ((!name.isEmpty()) && (name.get(0).length() == 0))
  +            name = name.getSuffix(1);
           if (name.isEmpty())
               return nameParser;
   
  @@ -435,7 +418,7 @@
               if (obj instanceof Context) {
                   return ((Context) obj).getNameParser(name.getSuffix(1));
               } else {
  -                throw new NotContextException( name.toString());
  +                throw new NotContextException(name.toString());
               }
           }
   
  @@ -446,115 +429,109 @@
   
       /**
        * Retrieves the parser associated with the named context.
  -     * 
  +     *
        * @param name the name of the context from which to get the parser
  -     * @return a name parser that can parse compound names into their atomic 
  +     * @return a name parser that can parse compound names into their atomic
        * components
        * @exception NamingException if a naming exception is encountered
        */
       public NameParser getNameParser(String name)
  -        throws NamingException
  -    {
  +            throws NamingException {
           return getNameParser(new CompositeName(name));
       }
   
       /**
        * Composes the name of this context with a name relative to this context.
        * <p>
  -     * Given a name (name) relative to this context, and the name (prefix) 
  -     * of this context relative to one of its ancestors, this method returns 
  -     * the composition of the two names using the syntax appropriate for the 
  -     * naming system(s) involved. That is, if name names an object relative 
  -     * to this context, the result is the name of the same object, but 
  +     * Given a name (name) relative to this context, and the name (prefix)
  +     * of this context relative to one of its ancestors, this method returns
  +     * the composition of the two names using the syntax appropriate for the
  +     * naming system(s) involved. That is, if name names an object relative
  +     * to this context, the result is the name of the same object, but
        * relative to the ancestor context. None of the names may be null.
  -     * 
  +     *
        * @param name a name relative to this context
        * @param prefix the name of this context relative to one of its ancestors
        * @return the composition of prefix and name
        * @exception NamingException if a naming exception is encountered
        */
       public Name composeName(Name name, Name prefix)
  -        throws NamingException
  -    {
  -	prefix = (Name) name.clone();
  -	return prefix.addAll(name);
  +            throws NamingException {
  +        prefix = (Name) name.clone();
  +        return prefix.addAll(name);
       }
   
   
       /**
        * Composes the name of this context with a name relative to this context.
  -     * 
  +     *
        * @param name a name relative to this context
        * @param prefix the name of this context relative to one of its ancestors
        * @return the composition of prefix and name
        * @exception NamingException if a naming exception is encountered
        */
       public String composeName(String name, String prefix)
  -        throws NamingException {
  +            throws NamingException {
           return prefix + "/" + name;
       }
   
   
       /**
  -     * Adds a new environment property to the environment of this context. If 
  +     * Adds a new environment property to the environment of this context. If
        * the property already exists, its value is overwritten.
  -     * 
  -     * @param propName the name of the environment property to add; may not 
  +     *
  +     * @param propName the name of the environment property to add; may not
        * be null
        * @param propVal the value of the property to add; may not be null
        * @exception NamingException if a naming exception is encountered
        */
       public Object addToEnvironment(String propName, Object propVal)
  -        throws NamingException
  -    {
  +            throws NamingException {
           return env.put(propName, propVal);
       }
   
   
       /**
  -     * Removes an environment property from the environment of this context. 
  -     * 
  -     * @param propName the name of the environment property to remove; 
  +     * Removes an environment property from the environment of this context.
  +     *
  +     * @param propName the name of the environment property to remove;
        * may not be null
        * @exception NamingException if a naming exception is encountered
        */
       public Object removeFromEnvironment(String propName)
  -        throws NamingException
  -    {
  +            throws NamingException {
           return env.remove(propName);
       }
   
   
       /**
  -     * Retrieves the environment in effect for this context. See class 
  -     * description for more details on environment properties. 
  -     * The caller should not make any changes to the object returned: their 
  -     * effect on the context is undefined. The environment of this context 
  +     * Retrieves the environment in effect for this context. See class
  +     * description for more details on environment properties.
  +     * The caller should not make any changes to the object returned: their
  +     * effect on the context is undefined. The environment of this context
        * may be changed using addToEnvironment() and removeFromEnvironment().
  -     * 
  +     *
        * @return the environment of this context; never null
        * @exception NamingException if a naming exception is encountered
        */
       public Hashtable getEnvironment()
  -        throws NamingException
  -    {
  +            throws NamingException {
           return env;
       }
   
   
       /**
  -     * Closes this context. This method releases this context's resources 
  -     * immediately, instead of waiting for them to be released automatically 
  +     * Closes this context. This method releases this context's resources
  +     * immediately, instead of waiting for them to be released automatically
        * by the garbage collector.
  -     * This method is idempotent: invoking it on a context that has already 
  -     * been closed has no effect. Invoking any other method on a closed 
  +     * This method is idempotent: invoking it on a context that has already
  +     * been closed has no effect. Invoking any other method on a closed
        * context is not allowed, and results in undefined behaviour.
  -     * 
  +     *
        * @exception NamingException if a naming exception is encountered
        */
       public void close()
  -        throws NamingException
  -    {
  +            throws NamingException {
           // We don't own the env., but the clone
           env.clear();
       }
  @@ -563,144 +540,139 @@
       /**
        * Retrieves the full name of this context within its own namespace.
        * <p>
  -     * Many naming services have a notion of a "full name" for objects in 
  -     * their respective namespaces. For example, an LDAP entry has a 
  -     * distinguished name, and a DNS record has a fully qualified name. This 
  -     * method allows the client application to retrieve this name. The string 
  -     * returned by this method is not a JNDI composite name and should not be 
  -     * passed directly to context methods. In naming systems for which the 
  -     * notion of full name does not make sense, 
  +     * Many naming services have a notion of a "full name" for objects in
  +     * their respective namespaces. For example, an LDAP entry has a
  +     * distinguished name, and a DNS record has a fully qualified name. This
  +     * method allows the client application to retrieve this name. The string
  +     * returned by this method is not a JNDI composite name and should not be
  +     * passed directly to context methods. In naming systems for which the
  +     * notion of full name does not make sense,
        * OperationNotSupportedException is thrown.
  -     * 
  +     *
        * @return this context's name in its own namespace; never null
  -     * @exception OperationNotSupportedException if the naming system does 
  +     * @exception OperationNotSupportedException if the naming system does
        * not have the notion of a full name
        * @exception NamingException if a naming exception is encountered
        */
       public String getNameInNamespace()
  -        throws NamingException
  -    {
  +            throws NamingException {
           throw new OperationNotSupportedException();
       }
   
       /**
  -     * Searches in the named context or object for entries that satisfy the 
  -     * given search filter. Performs the search as specified by the search 
  +     * Searches in the named context or object for entries that satisfy the
  +     * given search filter. Performs the search as specified by the search
        * controls.
  -     * 
  +     *
        * @param name the name of the context or object to search
  -     * @param filter the filter expression to use for the search; may not be 
  +     * @param filter the filter expression to use for the search; may not be
        * null
  -     * @param cons the search controls that control the search. If null, 
  -     * the default search controls are used (equivalent to 
  +     * @param cons the search controls that control the search. If null,
  +     * the default search controls are used (equivalent to
        * (new SearchControls())).
  -     * @return an enumeration of SearchResults of the objects that satisfy 
  +     * @return an enumeration of SearchResults of the objects that satisfy
        * the filter; never null
  -     * @exception InvalidSearchFilterException if the search filter specified 
  +     * @exception InvalidSearchFilterException if the search filter specified
        * is not supported or understood by the underlying directory
  -     * @exception InvalidSearchControlsException if the search controls 
  +     * @exception InvalidSearchControlsException if the search controls
        * contain invalid settings
        * @exception NamingException if a naming exception is encountered
        */
       public NamingEnumeration search
  -        (Name name, String filter, SearchControls cons)
  -        throws NamingException
  -    {
  +            (Name name, String filter, SearchControls cons)
  +            throws NamingException {
           return search(name.toString(), filter, cons);
       }
   
   
       /**
  -     * Searches in the named context or object for entries that satisfy the 
  -     * given search filter. Performs the search as specified by the search 
  +     * Searches in the named context or object for entries that satisfy the
  +     * given search filter. Performs the search as specified by the search
        * controls.
  -     * 
  +     *
        * @param name the name of the context or object to search
  -     * @param filter the filter expression to use for the search; may not be 
  +     * @param filter the filter expression to use for the search; may not be
        * null
  -     * @param cons the search controls that control the search. If null, 
  -     * the default search controls are used (equivalent to 
  +     * @param cons the search controls that control the search. If null,
  +     * the default search controls are used (equivalent to
        * (new SearchControls())).
  -     * @return an enumeration of SearchResults of the objects that satisfy 
  +     * @return an enumeration of SearchResults of the objects that satisfy
        * the filter; never null
  -     * @exception InvalidSearchFilterException if the search filter 
  +     * @exception InvalidSearchFilterException if the search filter
        * specified is not supported or understood by the underlying directory
  -     * @exception InvalidSearchControlsException if the search controls 
  +     * @exception InvalidSearchControlsException if the search controls
        * contain invalid settings
        * @exception NamingException if a naming exception is encountered
        */
  -    public NamingEnumeration search(String name, String filter, 
  -                                             SearchControls cons)
  -        throws NamingException
  -    {
  +    public NamingEnumeration search(String name, String filter,
  +                                    SearchControls cons)
  +            throws NamingException {
           throw new OperationNotSupportedException();
       }
   
   
       /**
  -     * Searches in the named context or object for entries that satisfy the 
  -     * given search filter. Performs the search as specified by the search 
  +     * Searches in the named context or object for entries that satisfy the
  +     * given search filter. Performs the search as specified by the search
        * controls.
  -     * 
  +     *
        * @param name the name of the context or object to search
  -     * @param filterExpr the filter expression to use for the search. 
  -     * The expression may contain variables of the form "{i}" where i is a 
  +     * @param filterExpr the filter expression to use for the search.
  +     * The expression may contain variables of the form "{i}" where i is a
        * nonnegative integer. May not be null.
  -     * @param filterArgs the array of arguments to substitute for the 
  -     * variables in filterExpr. The value of filterArgs[i] will replace each 
  +     * @param filterArgs the array of arguments to substitute for the
  +     * variables in filterExpr. The value of filterArgs[i] will replace each
        * occurrence of "{i}". If null, equivalent to an empty array.
  -     * @param cons the search controls that control the search. If null, the 
  +     * @param cons the search controls that control the search. If null, the
        * default search controls are used (equivalent to (new SearchControls())).
  -     * @return an enumeration of SearchResults of the objects that satisy the 
  +     * @return an enumeration of SearchResults of the objects that satisy the
        * filter; never null
  -     * @exception ArrayIndexOutOfBoundsException if filterExpr contains {i} 
  +     * @exception ArrayIndexOutOfBoundsException if filterExpr contains {i}
        * expressions where i is outside the bounds of the array filterArgs
  -     * @exception InvalidSearchControlsException if cons contains invalid 
  +     * @exception InvalidSearchControlsException if cons contains invalid
        * settings
  -     * @exception InvalidSearchFilterException if filterExpr with filterArgs 
  +     * @exception InvalidSearchFilterException if filterExpr with filterArgs
        * represents an invalid search filter
        * @exception NamingException if a naming exception is encountered
        */
  -    public NamingEnumeration search(Name name, String filterExpr, 
  +    public NamingEnumeration search(Name name, String filterExpr,
                                       Object[] filterArgs, SearchControls cons)
  -        throws NamingException
  -    {
  +            throws NamingException {
           return search(name.toString(), filterExpr, filterArgs, cons);
       }
   
   
       /**
  -     * Searches in the named context or object for entries that satisfy the 
  -     * given search filter. Performs the search as specified by the search 
  +     * Searches in the named context or object for entries that satisfy the
  +     * given search filter. Performs the search as specified by the search
        * controls.
  -     * 
  +     *
        * @param name the name of the context or object to search
  -     * @param filterExpr the filter expression to use for the search. 
  -     * The expression may contain variables of the form "{i}" where i is a 
  +     * @param filterExpr the filter expression to use for the search.
  +     * The expression may contain variables of the form "{i}" where i is a
        * nonnegative integer. May not be null.
  -     * @param filterArgs the array of arguments to substitute for the 
  -     * variables in filterExpr. The value of filterArgs[i] will replace each 
  +     * @param filterArgs the array of arguments to substitute for the
  +     * variables in filterExpr. The value of filterArgs[i] will replace each
        * occurrence of "{i}". If null, equivalent to an empty array.
  -     * @param cons the search controls that control the search. If null, the 
  +     * @param cons the search controls that control the search. If null, the
        * default search controls are used (equivalent to (new SearchControls())).
  -     * @return an enumeration of SearchResults of the objects that satisy the 
  +     * @return an enumeration of SearchResults of the objects that satisy the
        * filter; never null
  -     * @exception ArrayIndexOutOfBoundsException if filterExpr contains {i} 
  +     * @exception ArrayIndexOutOfBoundsException if filterExpr contains {i}
        * expressions where i is outside the bounds of the array filterArgs
  -     * @exception InvalidSearchControlsException if cons contains invalid 
  +     * @exception InvalidSearchControlsException if cons contains invalid
        * settings
  -     * @exception InvalidSearchFilterException if filterExpr with filterArgs 
  +     * @exception InvalidSearchFilterException if filterExpr with filterArgs
        * represents an invalid search filter
        * @exception NamingException if a naming exception is encountered
        */
  -    public  NamingEnumeration search(String name, String filterExpr, 
  -                                         Object[] filterArgs,
  -                                         SearchControls cons)
  -        throws NamingException
  -    {
  +    public NamingEnumeration search(String name, String filterExpr,
  +                                    Object[] filterArgs,
  +                                    SearchControls cons)
  +            throws NamingException {
           throw new OperationNotSupportedException();
       }
   
  -    
  +
   }
   
  
  
  

--
To unsubscribe, e-mail:   <mailto:tomcat-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:tomcat-dev-help@jakarta.apache.org>


Mime
View raw message