/*
 *
 *
 * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation. 
 * 
 * This program 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 version 2 for more details (a copy is
 * included at /legal/license.txt). 
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA 
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions. 
 */

package com.sun.midp.content;

import javax.microedition.content.ContentHandler;
import javax.microedition.content.ContentHandlerServer;
import javax.microedition.content.RequestListener;
import javax.microedition.content.ActionNameMap;
import javax.microedition.content.Invocation;

import java.io.DataInputStream;
import java.io.DataOutputStream;

/**
 * The internal structure of a registered content handler.
 */
public class ContentHandlerImpl implements ContentHandler {

    /**
     * The content handler ID.
     * Lengths up to 256 characters MUST be supported.
     * The ID may be <code>null</code>.
     */
    String ID;

    /**
     * The types that are supported by this content handler.
     * If there are no types registered, the this field MUST either be
     * <code>null</code> or refer to an empty array .
     */
    private String[] types;

    /**
     * The suffixes of URLs that are supported by this content handler.
     * If there are no suffixes, then this field MUST be <code>null</code>.
     * The suffixes MUST include any and all punctuation. For example,
     * the string <code>".png"</code>.
     */
    private String[] suffixes;

    /**
     * The actions that are supported by this content handler.
     * If there are no actions, then this field MSUT be <code>null</code>.
     */
    private String[] actions;

    /**
     * The action names that are defined by this content handler.
     */
    ActionNameMap[] actionnames;

    /** The sequence number of this instance; monotonic increasing. */
    final int seqno;

    /** The next sequence number to assign. */
    private static int nextSeqno;

    /**
     * The RequestListenerImpl; if a listener is set.
     */
    RequestListenerImpl listenerImpl;

    /** Empty String array to return when needed. */
    public final static String[] ZERO_STRINGS = {};

    /** Empty ActionNameMap to return when needed. */
    private final static ActionNameMap[] ZERO_ACTIONNAMES =
        new ActionNameMap[0];

    /** Property name for the current locale. */
    private final static String LOCALE_PROP = "microedition.locale";

    /**
     * The MIDlet suite storagename that contains the MIDlet.
     */
    int storageId;

    /**
     * The Name from parsing the Property for the MIDlet
     * with this classname.
     */
    String appname;

    /**
     * The Version parsed from MIDlet-Version attribute.
     */
    String version;

    /**
     * The application class name that implements this content
     * handler.  Note: Only the application that registered the class
     * will see the classname; for other applications the value will be
     * <code>null</code>.
     */
    String classname;

    /**
     * The authority that authenticated this ContentHandler.
     */
    String authority;

    /**
     * The accessRestrictions for this ContentHandler.
     */
    private String[] accessRestricted;

    /**
     * Indicates content handler registration method:
     * dynamic registration from the API, static registration from install
     * or native content handler.
     * Must be similar to enum in jsr211_registry.h
     */
    int registrationMethod;

    /** Content handler statically registered during installation */
    final static int REGISTERED_STATIC = 0;
    /** Dynamically registered content handler via API */
    final static int REGISTERED_DYNAMIC = 1;
    /** Native platform content handler  */
    final static int REGISTERED_NATIVE  = 2;

    /** Count of requests retrieved via {@link #getRequest}. */
    int requestCalls;

    /**
     * Instance is a registration or unregistration.
     * An unregistration needs only storageId and classname.
     */
    boolean removed;

    /**
     * Construct a ContentHandlerImpl.
     * Verifies that all strings are non-null
     * @param types an array of types to register; may be
     *  <code>null</code>
     * @param suffixes an array of suffixes to register; may be
     *  <code>null</code>
     * @param actions an array of actions to register; may be
     *  <code>null</code>
     * @param actionnames an array of ActionNameMaps to register; may be
     *  <code>null</code>
     * @param ID the content handler ID; may be <code>null</code>
     * @param accessRestricted the  IDs of applications allowed access
     * @param auth application authority
     *
     * @exception NullPointerException if any types, suffixes,
     *   actions, actionnames array element is null
     *
     * @exception IllegalArgumentException is thrown if any of
     *   the types, suffix, or action strings have a
     *   length of zero or
     *   if the ID has a length of zero or contains any
     *        control character or space (U+0000-U+00020)
     */
    ContentHandlerImpl(String[] types, String[] suffixes,
                       String[] actions, ActionNameMap[] actionnames,
                       String ID, String[] accessRestricted, String auth) {
        this();

        // Verify consistency between actions and ActionNameMaps
        if (actionnames != null && actionnames.length > 0) {
            if (actions == null) {
                throw new IllegalArgumentException("no actions");
            }
            int len = actions.length;
            for (int i = 0; i < actionnames.length; i++) {
                // Verify the actions are the same
                ActionNameMap map = actionnames[i];
                if (len != map.size()) {
                    throw new IllegalArgumentException("actions not identical");
                }

                for (int j = 0; j < len; j++) {
                    if (!actions[j].equals(map.getAction(j))) {
                        throw new
                            IllegalArgumentException("actions not identical");
                    }
                }

                /*
                 * Verify the locale of this ActionNameMap is not the same
                 * as any previous ActionNameMap.
                 */
                for (int j = 0; j < i; j++) {
                    if (map.getLocale().equals(actionnames[j].getLocale())) {
                        throw new IllegalArgumentException("duplicate locale");
                    }
                }
            }
        }

        // Check the ID for invalid characters (controls or space)
        if (ID != null) {
            int len = ID.length();
            if (len == 0) {
                    throw new IllegalArgumentException("invalid ID");
            }
            for (int i = 0; i < ID.length(); i++) {
                if (ID.charAt(i) <= 0x0020) {
                    throw new IllegalArgumentException("invalid ID");
                }
            }
            this.ID = ID;
        }
        this.types = copy(types);
        this.suffixes = copy(suffixes);
        this.actions = copy(actions);
        this.actionnames = copy(actionnames);
        this.accessRestricted = copy(accessRestricted);
        this.authority = auth;
    }

    /**
     * Initialize a new instance with the same information.
     * @param handler another ContentHandlerImpl
     * @see javax.microedition.content.ContentHandlerServerImpl
     */
    protected ContentHandlerImpl(ContentHandlerImpl handler) {
        this();
        types = handler.types;
        suffixes = handler.suffixes;
        ID = handler.ID;
        accessRestricted = handler.accessRestricted;
        actions = handler.actions;
        actionnames = handler.actionnames;
        listenerImpl = handler.listenerImpl;
        storageId = handler.storageId;
        classname = handler.classname;
        version = handler.version;
        registrationMethod = handler.registrationMethod;
        requestCalls = handler.requestCalls;
        authority = handler.authority;
        appname = handler.appname;
    }

    /**
     * Constructor used to read handlers.
     */
    ContentHandlerImpl() {
        seqno = nextSeqno++;
    }

    /**
     * Checks that all of the string references are non-null
     * and not zero length.  If either the argument is null or
     * is an empty array the default ZERO length string array is used.
     *
     * @param strings array to check for null and length == 0
     * @return a non-null array of strings; an empty array replaces null
     * @exception NullPointerException if any string ref is null
     * @exception IllegalArgumentException if any string
     * has length == 0
     */
    public static String[] copy(String[] strings) {
        if (strings != null && strings.length > 0) {
            String[] copy = new String[strings.length];
            for (int i = 0; i < strings.length; i++) {
                if (strings[i].length() == 0) {
                    throw new IllegalArgumentException("string length is 0");
                }
                copy[i] = strings[i];

            }
            return strings;
        } else {
            return ZERO_STRINGS;
        }
    }
    /**
     * Checks that all of the actionname references are non-null.
     *
     * @param actionnames array to check for null and length == 0
     * @return a non-null array of actionnames; an empty array replaces null
     * @exception NullPointerException if any string ref is null
     */
    private static ActionNameMap[] copy(ActionNameMap[] actionnames) {
        if (actionnames != null && actionnames.length > 0) {
            ActionNameMap[] copy = new ActionNameMap[actionnames.length];
            for (int i = 0; i < actionnames.length; i++) {
                // Check for null
                if (actionnames[i] == null) {
                    throw new NullPointerException();
                }
                copy[i] = actionnames[i];
            }
            return copy;
        } else {
            return ZERO_ACTIONNAMES;
        }
    }

    /**
     * Copy an array of ContentHandlers making a new ContentHandler
     * for each ContentHandler.  Make copies of any mutiple object.
     * @param handlers the array of handlers duplicate
     * @return the new array of content handlers
     */
    public static ContentHandler[] copy(ContentHandler[] handlers) {
        ContentHandler[] h = new ContentHandler[handlers.length];
        for (int i = 0; i < handlers.length; i++) {
            h[i] = handlers[i];
        }
        return h;
    }

    /**
     * Get the nth type supported by the content handler.
     * @param index the index into the types
     * @return the nth type
     * @exception IndexOutOfBounds if index is less than zero or
     *     greater than or equal to the value of the
     *     {@link #getTypeCount getTypeCount} method.
     */
    public String getType(int index) {
        return get(index, getTypes());
    }


    /**
     * Get the number of types supported by the content handler.
     *
     * @return the number of types
     */
    public int getTypeCount() {
        return getTypes().length;
    }

    /**
     * Get types supported by the content handler.
     *
     * @return array of types supported
     */
    String [] getTypes() {
        if (types == null) {
            types = RegistryStore.getArrayField(ID, RegistryStore.FIELD_TYPES);
        }
        return types;
    }

    /**
     * Determine if a type is supported by the content handler.
     *
     * @param type the type to check for
     * @return <code>true</code> if the type is supported;
     *  <code>false</code> otherwise
     * @exception NullPointerException if <code>type</code>
     * is <code>null</code>
     */
    public boolean hasType(String type) {
        return has(type, getTypes(), true);
    }

    /**
     * Get the nth suffix supported by the content handler.
     * @param index the index into the suffixes
     * @return the nth suffix
     * @exception IndexOutOfBounds if index is less than zero or
     *     greater than or equal to the value of the
     *     {@link #getSuffixCount getSuffixCount} method.
     */
    public String getSuffix(int index) {
        return get(index, getSuffixes());
    }

    /**
     * Get the number of suffixes supported by the content handler.
     *
     * @return the number of suffixes
     */
    public int getSuffixCount() {
        return getSuffixes().length;
    }

    /**
     * Determine if a suffix is supported by the content handler.
     *
     * @param suffix the suffix to check for
     * @return <code>true</code> if the suffix is supported;
     *  <code>false</code> otherwise
     * @exception NullPointerException if <code>suffix</code>
     * is <code>null</code>
     */
    public boolean hasSuffix(String suffix) {
        return has(suffix, getSuffixes(), true);
    }

    /**
     * Get suffixes supported by the content handler.
     *
     * @return array of suffixes supported
     */
    String [] getSuffixes() {
        if (suffixes == null) {
            suffixes =
                RegistryStore.getArrayField(ID, RegistryStore.FIELD_SUFFIXES);
        }
        return suffixes;
    }

    /**
     * Get the nth action supported by the content handler.
     * @param index the index into the actions
     * @return the nth action
     * @exception IndexOutOfBounds if index is less than zero or
     *     greater than or equal to the value of the
     *     {@link #getActionCount getActionCount} method.
     */
    public String getAction(int index) {
        return get(index, getActions());
    }

    /**
     * Get the number of actions supported by the content handler.
     *
     * @return the number of actions
     */
    public int getActionCount() {
        return getActions().length;
    }

    /**
     * Determine if a action is supported by the content handler.
     *
     * @param action the action to check for
     * @return <code>true</code> if the action is supported;
     *  <code>false</code> otherwise
     * @exception NullPointerException if <code>action</code>
     * is <code>null</code>
     */
    public boolean hasAction(String action) {
        return has(action, getActions(), false);
    }

    /**
     * Get actions supported by the content handler.
     *
     * @return array of actions supported
     */
    String [] getActions() {
        if (actions == null) {
            actions =
                RegistryStore.getArrayField(ID, RegistryStore.FIELD_ACTIONS);
        }
        return actions;
    }

    /**
     * Gets the value at index in the string array.
     * @param index of the value
     * @param strings array of strings to get from
     * @return string at index.
     * @exception IndexOutOfBounds if index is less than zero or
     *     greater than or equal length of the array.
     */
    private String get(int index, String[] strings) {
        if (index < 0 || index >= strings.length) {
            throw new IndexOutOfBoundsException();
        }
        return strings[index];
    }

    /**
     * Determines if the string is in the array.
     * @param string to locate
     * @param strings array of strings to get from
     * @param ignoreCase true to ignore case in matching
     * @return <code>true</code> if the value is found
     * @exception NullPointerException if <code>string</code>
     * is <code>null</code>
     */
    private boolean has(String string, String[] strings, boolean ignoreCase) {
        int len = string.length(); // Throw NPE if null
        for (int i = 0; i < strings.length; i++) {
            if (strings[i].length() == len &&
                string.regionMatches(ignoreCase, 0, strings[i], 0, len)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Get the mapping of actions to action names for the current
     * locale supported by this content handler. The behavior is
     * the same as invoking {@link #getActionNameMap} with the current
     * locale.
     *
     * @return an ActionNameMap; if there is no map available for the
     *  current locale, then it MUST be <code>null</code>
     */
    public ActionNameMap getActionNameMap() {
        String locale = System.getProperty(LOCALE_PROP);
        return (locale == null) ? null : getActionNameMap(locale);
    }

    /**
     * Get the mapping of actions to action names for the requested
     * locale supported by this content handler.
     * The locale is matched against the available locales.
     * If a match is found it is used.  If an exact match is
     * not found, then the locale string is shortened and retried
     * if either of the "_" or "-" delimiters is present.
     * The locale is shortened by retaining only the characters up to
     * but not including the last occurence of the delimiter
     * (either "_" or "-").
     * The shortening and matching is repeated as long as the string
     * contains one of the delimiters.
     * Effectively, this will try the full locale and then try
     * without the variant or country code, if they were present.
     *
     * @param locale for which to find an ActionNameMap;
     *   MUST NOT be <code>null</code>
     * @return an ActionNameMap; if there is no map available for the
     *  locale, then it MUST be <code>null</code>
     * @exception NullPointerException if the locale is <code>null</code>
     */
    public ActionNameMap getActionNameMap(String locale) {
        while (locale.length() > 0) {
            for (int i = 0; i < getActionNames().length; i++) {
                if (locale.equals(getActionNames()[i].getLocale())) {
                    return getActionNames()[i];
                }
            }
            int lastdash = locale.lastIndexOf('-');
            if (lastdash < 0) {
                break;
            }
            locale = locale.substring(0, lastdash);
        }
        return null;
    }

    /**
     * Gets the number of action name maps supported by the content handler.
     *
     * @return the number of action name maps
     */
    public int getActionNameMapCount() {
        return getActionNames().length;
    }

    /**
     * Gets the n<sup>th</sup> ActionNameMap supported by the
     * content handler.
     * @param index the index of the locale
     * @return the n<sup>th</sup> ActionNameMap
     *
     * @exception IndexOutOfBoundsException if index is less than zero or
     *     greater than or equal to the value of the
     *     {@link #getActionNameMapCount getActionNameMapCount} method.
     */
    public ActionNameMap getActionNameMap(int index) {
        if (index < 0 || index >= getActionNames().length) {
            throw new IndexOutOfBoundsException();
        }
        return getActionNames()[index];
    }

    /**
     * Get actions names for the content handler.
     *
     * @return array of actions names
     */
    private ActionNameMap[] getActionNames() {
        if (actionnames == null) {
            String [] locales =
                RegistryStore.getArrayField(ID, RegistryStore.FIELD_LOCALES);
            String [] names   =
                RegistryStore.getArrayField(ID, RegistryStore.FIELD_ACTION_MAP);

            actionnames = new ActionNameMap[locales.length];
            for (int index = 0; index < locales.length; index++) {
                String [] temp = new String[getActions().length];

                System.arraycopy(names,
                                 index * getActions().length,
                                 temp,
                                 0,
                                 getActions().length);

                actionnames[index] = new ActionNameMap(getActions(),
                                                       temp,
                                                       locales[index]);
            }
        }
        return actionnames;
    }

    /**
     * Returns the name used to present this content handler to a user.
     * The value is extracted from the normal installation information
     * about the content handler application.
     *
     * @return the user-friendly name of the application;
     * it MUST NOT be <code>null</code>
     */
    public String getAppName() {
        loadAppData();
        return appname;
    }

    /**
     * Gets the version number of this content handler.
     * The value is extracted from the normal installation information
     * about the content handler application.
     * @return the version number of the application;
     * MAY be <code>null</code>
     */
    public String getVersion() {
        loadAppData();
        return version;
    }

    /**
     * Get the content handler ID.  The ID uniquely identifies the
     * application which contains the content handler.
     * After registration and for every registered handler,
     * the ID MUST NOT be <code>null</code>.
     * @return the ID; MUST NOT be <code>null</code> unless the
     *  ContentHandler is not registered.
     */
    public String getID() {
        return ID;
    }

    /**
     * Gets the name of the authority that authorized this application.
     * This value MUST be <code>null</code> unless the device has been
     * able to authenticate this application.
     * If <code>non-null</code>, it is the string identifiying the
     * authority.  For example,
     * if the application was a signed MIDlet, then this is the
     * "subject" of the certificate used to sign the application.
     * <p>The format of the authority for X.509 certificates is defined
     * by the MIDP Printable Representation of X.509 Distinguished
     * Names as defined in class
     * <code>javax.microedition.pki.Certificate</code>. </p>
     *
     * @return the authority; may be <code>null</code>
     */
    public String getAuthority() {
        loadAppData();
        return authority;
    }

    /**
     * Initializes fields retrieved from AppProxy 'by-demand'.
     */
    private void loadAppData() {
        if (appname == null) {
            try {
                AppProxy app = 
                        AppProxy.getCurrent().forApp(storageId, classname);
                appname = app.getApplicationName();
                version = app.getVersion();
                authority = app.getAuthority();
            } catch (Throwable t) {
            }
            if (appname == null) {
                appname = "";
            }
        }
    }

    /**
     * Gets the n<sup>th</sup> ID of an application or content handler
     * allowed access to this content handler.
     * The ID returned for each index must be the equal to the ID
     * at the same index in the <tt>accessAllowed</tt> array passed to
     * {@link javax.microedition.content.Registry#register Registry.register}.
     *
     * @param index the index of the ID
     * @return the n<sup>th</sup> ID
     * @exception IndexOutOfBoundsException if index is less than zero or
     *     greater than or equal to the value of the
     *     {@link #accessAllowedCount accessAllowedCount} method.
     */
    public String getAccessAllowed(int index) {
        return get(index, getAccessRestricted());
    }

    /**
     * Gets the number of IDs allowed access by the content handler.
     * The number of IDs must be equal to the length of the array
     * of accessRestricted passed to
     * {@link javax.microedition.content.Registry#register Registry.register}.
     * If the number of IDs is zero then all applications and
     * content handlers are allowed access.
     *
     * @return the number of accessRestricteds
     */
    public int accessAllowedCount() {
        return getAccessRestricted().length;
    }

    /**
     * Determines if an ID MUST be allowed access by the content handler.
     * Access MUST be allowed if the ID has a prefix that exactly matches
     * any of the IDs returned by {@link #getAccessAllowed}.
     * The prefix comparison is equivalent to
     * <code>java.lang.String.startsWith</code>.
     *
     * @param ID the ID for which to check access
     * @return <code>true</code> if access MUST be allowed by the
     *  content handler;
     *  <code>false</code> otherwise
     * @exception NullPointerException if <code>accessRestricted</code>
     * is <code>null</code>
     */
    public boolean isAccessAllowed(String ID) {
        ID.length();                // check for null
        if (getAccessRestricted().length == 0) {
            return true;
        }
        for (int i = 0; i < getAccessRestricted().length; i++) {
            if (ID.startsWith(getAccessRestricted()[i])) {
                return true;
            }
        }
        return false;
    }

    /**
     * Get accesses for the content handler.
     *
     * @return array of allowed class names
     */
    private String [] getAccessRestricted() {
        if (accessRestricted == null) {
            accessRestricted =
                RegistryStore.getArrayField(ID, RegistryStore.FIELD_ACCESSES);
        }
        return accessRestricted;
    }

    /**
     * Gets the next Invocation request pending for this
     * ContentHandlerServer.
     * The method can be unblocked with a call to
     * {@link #cancelGetRequest cancelGetRequest}.
     * The application should process the Invocation as
     * a request to perform the <code>action</code> on the content.
     *
     * @param wait <code>true</code> if the method must wait for
     * for an Invocation if one is not available;
     * <code>false</code> if the method MUST NOT wait.
     * @param invocation an Invocation instance that will delegate to
     * the result; if any
     * @return the next pending Invocation or <code>null</code>
     *  if no Invocation is available; <code>null</code>
     *  if cancelled with {@link #cancelGetRequest cancelGetRequest}
     * @see javax.microedition.content.Registry#invoke
     * @see javax.microedition.content.ContentHandlerServer#finish
     */
    public InvocationImpl getRequest(boolean wait, Invocation invocation) {
        // Application has tried to get a request; reset cleanup flags on all
        if (requestCalls == 0) {
            InvocationStore.setCleanup(storageId, classname, false);
        }
        requestCalls++;

        InvocationImpl invoc =
            InvocationStore.getRequest(storageId, classname, wait);
        if (invoc != null) {
            // Keep track of number of requests delivered to the application
            AppProxy.requestForeground(invoc.invokingSuiteId,
                                       invoc.invokingClassname,
                                       invoc.suiteId,
                                       invoc.classname);
            invoc.invocation = invocation;
        }
        return invoc;
    }

    /**
     * Cancel a pending <code>getRequest</code>.
     * This method will force a Thread blocked in a call to the
     * <code>getRequest</code> method for the same application
     * context to return early.
     * If no Thread is blocked; this call has no effect.
     */
    public void cancelGetRequest() {
        InvocationStore.cancel();
    }

    /**
     * Finish this Invocation and set the status for the response.
     * The <code>finish</code> method may only be called when this
     * Invocation
     * has a status of <code>ACTIVE</code> or <code>HOLD</code>.
     * <p>
     * The content handler may modify the URL, type, action, or
     * arguments before invoking <code>finish</code>.
     * If the method {@link Invocation#getResponseRequired} returns
     * <code>true</code> then the modified
     * values MUST be returned to the invoking application.
     *
     * @param invoc the Invocation to finish
     * @param status the new status of the Invocation. This MUST be either
     *         <code>OK</code> or <code>CANCELLED</code>.
     *
     * @return <code>true</code> if the MIDlet suite MUST
     *   voluntarily exit before the response can be returned to the
     *   invoking application
     *
     * @exception IllegalArgumentException if the new
     *   <code>status</code> of the Invocation
     *    is not <code>OK</code> or <code>CANCELLED</code>
     * @exception IllegalStateException if the current
     *   <code>status</code> of the
     *   Invocation is not <code>ACTIVE</code> or <code>HOLD</code>
     * @exception NullPointerException if the invocation is <code>null</code>
     */
    protected boolean finish(InvocationImpl invoc, int status) {
        int currst = invoc.getStatus();
          if (currst != Invocation.ACTIVE && currst != Invocation.HOLD) {
             throw new IllegalStateException("Status already set");
         }
        // If ACTIVE or HOLD it must be an InvocationImpl
        return invoc.finish(status);
    }

    /**
     * Set the listener to be notified when a new request is
     * available for this content handler.  The request MUST
     * be retrieved using {@link #getRequest}.
     *
     * @param listener the listener to register;
     *   <code>null</code> to remove the listener.
     */
    public void setListener(RequestListener listener) {
        synchronized (this) {
            if (listener != null || listenerImpl != null) {
                // Create or update the active listener thread
                if (listenerImpl == null) {
                    listenerImpl =
                        new RequestListenerImpl(this, listener);
                } else {
                    listenerImpl.setListener(listener);
                }

                // If the listener thread no longer needed; clear it
                if (listener == null) {
                    listenerImpl = null;
                }
            }
        }
    }

    /**
     * Notify the request listener of a pending request.
     * Overridden by subclass.
     */
    protected void requestNotify() {
    }

    /**
     * Compare two ContentHandlerImpl's for equality.
     * Classname, storageID, and seqno must match.
     * @param other another ContentHandlerImpl
     * @return true if the other handler is for the same class,
     * storageID, and seqno.
     */
    boolean equals(ContentHandlerImpl other) {
        return seqno == other.seqno &&
            storageId == other.storageId &&
            classname.equals(other.classname);
    }

    /**
     * Debug routine to print the values.
     * @return a string with the details
     */
    public String toString() {
        if (AppProxy.LOG_INFO) {
            StringBuffer sb = new StringBuffer(80);
            sb.append("CH:");
            sb.append(" classname: ");
            sb.append(classname);
            sb.append(", removed: ");
            sb.append(removed);
            sb.append(", flag: ");
            sb.append(registrationMethod);
            sb.append(", types: ");
            toString(sb, types);
            sb.append(", ID: ");
            sb.append(ID);
            sb.append(", suffixes: ");
            toString(sb, suffixes);
            sb.append(", actions: ");
            toString(sb, actions);
            sb.append(", access: ");
            toString(sb, accessRestricted);
            sb.append(", suiteID: ");
            sb.append(storageId);
            sb.append(", authority: ");
            sb.append(authority);
            sb.append(", appname: ");
            sb.append(appname);
            return sb.toString();
        } else {
            return super.toString();
        }
    }

    /**
     * Append all of the strings inthe array to the string buffer.
     * @param sb a StringBuffer to append to
     * @param strings an array of strings.
     */
    private void toString(StringBuffer sb, String[] strings) {
        if (strings == null) {
            sb.append("null");
            return;
        }
        for (int i = 0; i < strings.length; i++) {
            if (i > 0) {
                sb.append(':');
            }
            sb.append(strings[i]);
        }
    }
}
