/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.context.externalize;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.xml.namespace.QName;

import org.apache.axis2.AxisFault;
import org.apache.axis2.description.AxisMessage;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.AxisServiceGroup;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.TransportInDescription;
import org.apache.axis2.description.WSDL11ToAllAxisServicesBuilder;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.engine.Handler;
import org.apache.axis2.transport.TransportListener;
import org.apache.axis2.util.MetaDataEntry;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;


/**
 * Some Externalize objects must be "activated" after they are read.
 * Activation normally involves associating the object with objects in the current
 * runtime.
 * 
 * ActivateUtils provides activation related utilities
 */
public class ActivateUtils {
    
    private static final Log log = LogFactory.getLog(ActivateUtils.class);
    
    /**
     * Private Constructor
     * All methods in ActivateUtils are static.
     */
    private ActivateUtils() {}

    /**
     * Find the AxisServiceGroup object that matches the criteria
     * <p/>
     * <B>Note<B> the saved service group meta information may not
     * match up with any of the serviceGroups that
     * are in the current AxisConfiguration object.
     * 
     * @param axisConfig The AxisConfiguration object
     * @param serviceGrpClassName the class name string for the target object
     *                   (could be a derived class)
     * @param serviceGrpName      the name associated with the service group
     * @return the AxisServiceGroup object that matches the criteria
     */
    public static AxisServiceGroup findServiceGroup(AxisConfiguration axisConfig,
                                                    String serviceGrpClassName,
                                                    String serviceGrpName) {
        Iterator its = axisConfig.getServiceGroups();

        while (its.hasNext()) {
            AxisServiceGroup checkServiceGroup = (AxisServiceGroup) its.next();

            String tmpSGClassName = checkServiceGroup.getClass().getName();
            String tmpSGName = checkServiceGroup.getServiceGroupName();

            if (tmpSGClassName.equals(serviceGrpClassName)) {
                boolean found = false;

                // the serviceGroupName can be null, so either both the 
                // service group names are null or they match
                if ((tmpSGName == null) && (serviceGrpName == null)) {
                    found = true;
                } else if ((tmpSGName != null) && (tmpSGName.equals(serviceGrpName))) {
                    found = true;
                } else if (containsExternalizedAxisServiceName(checkServiceGroup, serviceGrpName)) {
                    found = true;
                }

                if (found) {
                    // trace point
                    if (log.isTraceEnabled()) {
                        log.trace("ObjectStateUtils:findServiceGroup(): returning  ["
                                + serviceGrpClassName + "]   [" + serviceGrpName + "]");
                    }

                    return checkServiceGroup;
                }
            }
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findServiceGroup(): [" + serviceGrpClassName + "]   ["
                    + serviceGrpName + "]  returning  [null]");
        }

        return null;
    }
    
    /**
     * Answer if there are any AxisServices in the specified ServiceGroup that have an externalized
     * name that matches the service group name.    
     * 
     * @param checkServiceGroup The AxisServiceGroup containing the AxisServies to check
     * @param serviceGrpName The name to check as the externalized name of the AxisService
     * @return true if the group contains an AxisService with that name; false otherwise.
     */
    private static boolean containsExternalizedAxisServiceName(
            AxisServiceGroup checkServiceGroup, String serviceGrpName) {
        boolean containsAxisService = false;
        if (serviceGrpName != null && checkServiceGroup != null) {
            // Get a list of AxisServices on the group
            // Iterate over them to see if any have the Externalized Name Parameter
            // If so and it mathces, then this service group name then use this service group
            Iterator axisServicesInGroup = checkServiceGroup.getServices();
            while (axisServicesInGroup.hasNext()) {
                AxisService checkService = (AxisService) axisServicesInGroup.next();
                String externalizedServiceName = 
                    (String) checkService.getParameterValue(EXTERNALIZED_AXIS_SERVICE_NAME);
                if (externalizedServiceName != null && 
                        externalizedServiceName.equals(serviceGrpName)) {
                    containsAxisService = true;
                    break;
                }
            }
        }
        return containsAxisService;
    }

    /**
     * Find the AxisService object that matches the criteria
     * 
     * @param axisConfig The AxisConfiguration object
     * @param serviceClassName the class name string for the target object
     *                   (could be a derived class)
     * @param serviceName      the name associated with the service
     * @return the AxisService object that matches the criteria
     */
    public static AxisService findService(AxisConfiguration axisConfig, String serviceClassName,
            String serviceName) {
        return findService(axisConfig, serviceClassName, serviceName, null);
    }
    private static final String EXTERNALIZED_AXIS_SERVICE_NAME 
        = "org.apache.axis2.context.externalize.AxisServiceName";
    public static AxisService findService(AxisConfiguration axisConfig, String serviceClassName,
                                          String serviceName, String extraName) {
        if (log.isDebugEnabled()) {
            log.debug("ActivateUtils.findService serviceName: " + serviceName +", extraName: "
                + extraName);
        }
        HashMap services = axisConfig.getServices();

        Iterator its = services.values().iterator();

        // We loop through all the axis services looking for an exact match of the name, and if 
        // it exists, the extra information of the fully qualified Service QName and the port
        // name.  If we find an exact match, including the name of the service, we stop looking.
        // If no exact match is found after searching the entire list, then we use the first 
        // match of the extra information we found.  Note that picking the first one found is arbitrary.
        boolean exactServiceNameMatch = false;
        AxisService foundService = null;
        while (its.hasNext() && !exactServiceNameMatch) {
            AxisService service = (AxisService) its.next();
            switch(checkAxisService(service, serviceClassName, serviceName, extraName)) {
            case NAME_MATCH:
                foundService = service;
                exactServiceNameMatch = true;
                break;
            case SERVICE_PORT_MATCH:
                if (foundService == null) {
                    foundService = service;
                }
                break;
            case NONE:
                break;
            }
        }
        if (foundService != null) {
            // Store the original serviceName on the service for use in findServiceGroup
            // This is the name from when the service was originally externalized.
            try {
                foundService.addParameter(EXTERNALIZED_AXIS_SERVICE_NAME, serviceName);
            } catch (AxisFault e) {
                // I don't think this can actually ever happen.  The exception occurs if the
                // parameter is locked, but this is the only code that references that parameter
                if (log.isDebugEnabled()) {
                    log.debug("Got fault trying to add parameter " + EXTERNALIZED_AXIS_SERVICE_NAME +
                            " for service name " + serviceName + " to AxisService " + foundService, e); 
                }
            }
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:findService(): returning  [" + serviceClassName
                        + "]   [" + serviceName + "] AxisService name [" + foundService.getName()
                        + "]");
            }

            return foundService;
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findService(): [" + serviceClassName + "]   ["
                    + serviceName + "]  returning  [null]");
        }
        return null;
    }
    // NONE means no match at all, NAME_MATCH means the service names match and the service and
    // port names match if they exist, and SERVICE_PORT_MATCH means only the service and port names
    // match (not the service names).
    private enum MatchType {NONE, NAME_MATCH, SERVICE_PORT_MATCH};
    
    /**
     * Determine if the AxisService passed in is a match for the name information passed in.
     * The type of match is returned as an enum.
     * 
     * @param serviceToCheck The AxisService to check against the other parameters
     * @param serviceClassName The name of class to look for
     * @param externalizedServiceName The name of the Service to look for.
     * @param externalizedExtraName Additional information beyond the name of the service to look 
     *  for
     * @return MatchType indication of the type of match for the passed in AxisService.
     */
    private static MatchType checkAxisService(AxisService serviceToCheck,
            String serviceClassName, String externalizedServiceName, String externalizedExtraName) {
        MatchType serviceIsSame = MatchType.NONE;

        String checkServiceClassName = serviceToCheck.getClass().getName();
        String checkServiceName = serviceToCheck.getName();
        String checkServiceExtraName = getAxisServiceExternalizeExtraName(serviceToCheck);
        if (checkServiceClassName.equals(serviceClassName)) {
            if ((externalizedExtraName == null || checkServiceExtraName == null)
                    && checkServiceName.equals(externalizedServiceName)) {
                // If we don't have an externalized extra name or there is no
                // externalized extra name information in the current Axis Service, then 
                // check the simple case where the AxisService names match
                serviceIsSame = MatchType.NAME_MATCH;
            } else if (externalizedExtraName != null && checkServiceExtraName != null
                    && checkServiceExtraName.equals(externalizedExtraName)){
                // If the service names also match each other, then consider this a name match
                // otherwise it is just a service & port match
                if (checkServiceName.equals(externalizedServiceName)) {
                    serviceIsSame = MatchType.NAME_MATCH;
                } else {
                    serviceIsSame = MatchType.SERVICE_PORT_MATCH;
                }
            } else {
                // This is not an error necessarily; just iterating through all of AxisServices
                // and some won't match.
                if (log.isDebugEnabled()) {
                    log.debug("No match: checking Externalized AxisService name: " + externalizedServiceName 
                            + " and extraName: " + externalizedExtraName 
                            + " against existing AxisService name: " + checkServiceName
                            + " and extraName: " + checkServiceExtraName);
                }
            }
        }

        return serviceIsSame;
        
    }

    // This String separates the ServiceQName and the Port LocalName in the extraName field
    // It is not a valid value in a QName so it can not accidently appear in a valid QName.
    private static String DELIMITER_SERVICE_PORT = " ";
    /**
     * Return a Sring that contains the service QName and port local name of an AxisService
     * seperated by a delimiter.  This value can be used as part of externalizing an AxisService
     * to provide additional information during deserialization in cases where the AxisService
     * name is not unique or does not match for whatever reasons.  
     * 
     * @param axisService The AxisService to create the externalized name
     * @return a String with the ServiceQName and port local name separated by DELIMITER_SERVICE_PORT
     * if both values exist as parameters on the service; null otherwise.
     */
    public static String getAxisServiceExternalizeExtraName(AxisService axisService) {
        String extraName = null;
        String serviceQName = null;
        String portName = null;
        
        Parameter serviceQNameParameter = 
            axisService.getParameter(WSDL11ToAllAxisServicesBuilder.WSDL_SERVICE_QNAME);
        if (serviceQNameParameter != null) {
            serviceQName = serviceQNameParameter.getValue().toString();
        }
        
        Parameter portNameParameter = 
            axisService.getParameter(WSDL11ToAllAxisServicesBuilder.WSDL_PORT); 
        if (portNameParameter != null) {
            portName = (String) portNameParameter.getValue();
        }
        
        if (serviceQName != null && portName != null) {
            extraName = serviceQName + DELIMITER_SERVICE_PORT +  portName;
        }
        
        return extraName;
    }
    


    /**
     * Find the AxisOperation object that matches the criteria
     * 
     * @param axisConfig The AxisConfiguration object
     * @param opClassName the class name string for the target object
     *                   (could be a derived class)
     * @param opQName    the name associated with the operation
     * @return the AxisOperation object that matches the given criteria
     */
    public static AxisOperation findOperation(AxisConfiguration axisConfig, String opClassName,
                                              QName opQName) {
        HashMap services = axisConfig.getServices();

        Iterator its = services.values().iterator();

        while (its.hasNext()) {
            AxisService service = (AxisService) its.next();

            Iterator ito = service.getOperations();

            while (ito.hasNext()) {
                AxisOperation operation = (AxisOperation) ito.next();

                String tmpOpName = operation.getClass().getName();
                QName tmpOpQName = operation.getName();

                if ((tmpOpName.equals(opClassName)) && (tmpOpQName.equals(opQName))) {
                    // trace point
                    if (log.isTraceEnabled()) {
                        log.trace("ObjectStateUtils:findOperation(axisCfg): returning  ["
                                + opClassName + "]   [" + opQName.toString() + "]");
                    }

                    return operation;
                }
            }
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findOperation(axisCfg): [" + opClassName + "]   ["
                    + opQName.toString() + "]  returning  [null]");
        }

        return null;
    }


    /**
     * Find the AxisOperation object that matches the criteria
     * 
     * @param service    The AxisService object
     * @param opClassName The class name string for the target object
     *                   (could be a derived class)
     * @param opQName    the name associated with the operation
     * @return the AxisOperation object that matches the given criteria
     */
    public static AxisOperation findOperation(AxisService service, String opClassName,
                                              QName opQName) {
        if (service == null) {
            return null;
        }

        Iterator ito = service.getOperations();

        // Previous versions of Axis2 didn't use a namespace on the operation name, so they wouldn't
        // have externalized a namespace.  If that's the case, only compare the localPart of the
        // operation name
        String namespace = opQName.getNamespaceURI();
        boolean ignoreNamespace = false;
        if (namespace == null || "".equals(namespace)) {
            ignoreNamespace = true;
        }
        
        while (ito.hasNext()) {
            AxisOperation operation = (AxisOperation) ito.next();

            String tmpOpName = operation.getClass().getName();
            QName tmpOpQName = operation.getName();
            
            if ((tmpOpName.equals(opClassName)) && 
                ((ignoreNamespace && (tmpOpQName.getLocalPart().equals(opQName.getLocalPart())) || (tmpOpQName.equals(opQName))))) {

                if (log.isTraceEnabled()) {
                    log.trace("ObjectStateUtils:findOperation(service): ignoreNamespace [" + ignoreNamespace
                    		+ "] returning  ["
                            + opClassName + "]   [" + opQName.toString() + "]");
                }

                return operation;
            }
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findOperation(service): ignoreNamespace [" + ignoreNamespace
                    + " classname [" + opClassName + "]  QName ["
                    + opQName.toString() + "]  returning  [null]");
        }

        return null;
    }

    /**
     * Find the AxisMessage object that matches the criteria
     * 
     * @param op             The AxisOperation object
     * @param msgName        The name associated with the message
     * @param msgElementName The name associated with the message element
     * @return the AxisMessage object that matches the given criteria
     */
    public static AxisMessage findMessage(AxisOperation op, String msgName, String msgElementName) {
        // Several kinds of AxisMessages can be associated with a particular 
        // AxisOperation.  The kinds of AxisMessages that are typically
        // accessible are associated with "in" and "out".  
        // There are also different kinds of AxisOperations, and each
        // type of AxisOperation can have its own mix of AxisMessages
        // depending on the style of message exchange pattern (mep)

        if (op == null) {
            // trace point
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:findMessage(): [" + msgName + "]  [" + msgElementName
                        + "] returning  [null] - no AxisOperation");
            }

            return null;
        }

        if (msgName == null) {
            // nothing to match with, expect to match against a name
            // trace point
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:findMessage(): [" + msgName + "]  [" + msgElementName
                        + "] returning  [null] - message name is not set");
            }

            return null;
        }


        String tmpName = null;
        String tmpElementName = null;

        //-------------------------------------
        // first try the "out" message
        //-------------------------------------
        AxisMessage out = null;
        try {
            out = op.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
        } catch (Exception ex) {
            // just absorb the exception
        }

        if (out != null) {
            tmpName = out.getName();

            QName tmpQout = out.getElementQName();
            if (tmpQout != null) {
                tmpElementName = tmpQout.toString();
            }
        }

        // check the criteria for a match

        boolean matching = matchMessageNames(tmpName, tmpElementName, msgName, msgElementName);

        if (matching) {
            // trace point
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:findMessage(): returning OUT message  [" + msgName
                        + "]  [" + msgElementName + "] ");
            }

            return out;
        }

        //-------------------------------------
        // next, try the "in" message 
        //-------------------------------------
        AxisMessage in = null;
        try {
            in = op.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
        } catch (Exception ex) {
            // just absorb the exception
        }

        if (in != null) {
            tmpName = in.getName();

            QName tmpQin = in.getElementQName();
            if (tmpQin != null) {
                tmpElementName = tmpQin.toString();
            }
        } else {
            tmpName = null;
            tmpElementName = null;
        }

        // check the criteria for a match

        matching = matchMessageNames(tmpName, tmpElementName, msgName, msgElementName);

        if (matching) {
            // trace point
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:findMessage(): returning IN message [" + msgName
                        + "]  [" + msgElementName + "] ");
            }

            return in;
        }

        // if we got here, then no match was found

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findMessage(): [" + msgName + "]  [" + msgElementName
                    + "] returning  [null]");
        }

        return null;
    }
    
    /**
     * Find the Handler object that matches the criteria
     * 
     * @param existingHandlers The list of existing handlers and phases
     * @param handlerClassName the class name string for the target object
     *                   (could be a derived class)
     * @return the Handler object that matches the criteria
     */
    public static Object findHandler(List<Handler> existingHandlers, MetaDataEntry metaDataEntry) //String handlerClassName)
    {

        String title = "ObjectStateUtils:findHandler(): ";

        String handlerClassName = metaDataEntry.getClassName();
        String qNameAsString = metaDataEntry.getQNameAsString();

        for (int i = 0; i < existingHandlers.size(); i++) {
            if (existingHandlers.get(i) != null) {
                String tmpClassName = existingHandlers.get(i).getClass().getName();
                String tmpName = ((Handler) existingHandlers.get(i)).getName().toString();

                if ((tmpClassName.equals(handlerClassName)) && (tmpName.equals(qNameAsString))) {
                    // trace point
                    if (log.isTraceEnabled()) {
                        log.trace(title + " [" + handlerClassName + "]  name [" + qNameAsString
                                + "]  returned");
                    }

                    return (Handler) (existingHandlers.get(i));
                }
            }
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace(title + " [" + handlerClassName + "]  name [" + qNameAsString
                    + "] was not found in the existingHandlers list");
        }

        return null;
    }
    
    /**
     * Find the TransportListener object that matches the criteria
     * <p/>
     * <B>Note<B> the saved meta information may not
     * match up with any of the objects that
     * are in the current AxisConfiguration object.
     * 
     * @param axisConfig The AxisConfiguration object
     * @param listenerClassName the class name string for the target object
     *                   (could be a derived class)
     * @return the TransportListener object that matches the criteria
     */
    public static TransportListener findTransportListener(AxisConfiguration axisConfig,
                                                          String listenerClassName) {
        // TODO: investigate a better technique to match up with a TransportListener

        HashMap transportsIn = axisConfig.getTransportsIn();

        // get a collection of the values in the map
        Collection values = transportsIn.values();

        Iterator i = values.iterator();

        while (i.hasNext()) {
            TransportInDescription ti = (TransportInDescription) i.next();

            TransportListener tl = ti.getReceiver();
            String tlClassName = tl.getClass().getName();

            if (tlClassName.equals(listenerClassName)) {
                // trace point
                if (log.isTraceEnabled()) {
                    log.trace("ObjectStateUtils:findTransportListener():  [" + listenerClassName
                            + "]  returned");
                }

                return tl;
            }
        }

        // trace point
        if (log.isTraceEnabled()) {
            log.trace("ObjectStateUtils:findTransportListener(): returning  [null]");
        }

        return null;
    }

    /**
     * Compares the two collections to see if they are equivalent.
     * 
     * @param a1  The first collection
     * @param a2  The second collection
     * @param strict  Indicates whether strict checking is required.  Strict
     *                checking means that the two collections must have the
     *                same elements in the same order.  Non-strict checking
     *                means that the two collections must have the same 
     *                elements, but the order is not significant.
     * @return TRUE if the two collections are equivalent
     *         FALSE, otherwise
     */
    public static boolean isEquivalent(ArrayList a1, ArrayList a2, boolean strict) {
        if ((a1 != null) && (a2 != null)) {
            // check number of elements in lists
            int size1 = a1.size();
            int size2 = a2.size();

            if (size1 != size2) {
                // trace point
                if (log.isTraceEnabled()) {
                    log.trace("ObjectStateUtils:isEquivalent(ArrayList,ArrayList): FALSE - size mismatch ["
                            + size1 + "] != [" + size2 + "]");
                }
                return false;
            }

            if (strict) {
                // Strict checking
                // The lists must contain the same elements in the same order.
                return (a1.equals(a2));
            } else {
                // Non-strict checking
                // The lists must contain the same elements but the order is not required.
                Iterator i1 = a1.iterator();

                while (i1.hasNext()) {
                    Object obj1 = i1.next();

                    if (!a2.contains(obj1)) {
                        // trace point
                        if (log.isTraceEnabled()) {
                            log.trace("ObjectStateUtils:isEquivalent(ArrayList,ArrayList): FALSE - mismatch with element ["
                                    + obj1.getClass().getName() + "] ");
                        }
                        return false;
                    }
                }

                return true;
            }

        } else if ((a1 == null) && (a2 == null)) {
            return true;
        } else if ((a1 != null) && (a2 == null)) {
            if (a1.size() == 0) {
                return true;
            }
            return false;
        } else if ((a1 == null) && (a2 != null)) {
            if (a2.size() == 0) {
                return true;
            }
            return false;
        } else {
            // mismatch

            // trace point
            if (log.isTraceEnabled()) {
                log.trace("ObjectStateUtils:isEquivalent(ArrayList,ArrayList): FALSE - mismatch in lists");
            }
            return false;
        }
    }

    /**
     * Compares the two collections to see if they are equivalent.
     * 
     * @param m1  The first collection
     * @param m2  The second collection
     * @param strict  Indicates whether strict checking is required.  Strict
     *                checking means that the two collections must have the
     *                same mappings.  Non-strict checking means that the 
     *                two collections must have the same keys.  In both
     *                cases, the order is not significant.
     * @return TRUE if the two collections are equivalent
     *         FALSE, otherwise
     */
    public static boolean isEquivalent(Map m1, Map m2, boolean strict) {
        if ((m1 != null) && (m2 != null)) {
            if (strict) {
                // This is a strict test.
                // Returns true if the given object is also a map and the two Maps 
                // represent the same mappings. 
                return (m1.equals(m2));
            } else {
                int size1 = m1.size();
                int size2 = m2.size();

                if (size1 != size2) {
                    return false;
                }

                // check the keys, ordering is not important between the two maps
                Iterator it1 = m1.keySet().iterator();

                while (it1.hasNext()) {
                    Object key1 = it1.next();

                    if (m2.containsKey(key1) == false) {
                        return false;
                    }
                }

                return true;
            }
        } else if ((m1 == null) && (m2 == null)) {
            return true;
        } else {
            // mismatch
            return false;
        }
    }


    /**
     * Compares the two collections to see if they are equivalent.
     * 
     * @param l1  The first collection
     * @param l2  The second collection
     * @return TRUE if the two collections are equivalent
     *         FALSE, otherwise
     */
    public static boolean isEquivalent(LinkedList l1, LinkedList l2) {
        if ((l1 != null) && (l2 != null)) {
            // This is a strict test.
            // Returns true if the specified object is also a list, 
            // both lists have the same size, and all corresponding pairs 
            // of elements in the two lists are equal where
            // they contain the same elements in the same order.
            return (l1.equals(l2));
        } else if ((l1 == null) && (l2 == null)) {
            return true;
        } else {
            // mismatch
            return false;
        }
    }
    
    /**
     * Check the first set of names for a match against
     * the second set of names.  These names are 
     * associated with AxisMessage objects. Message names
     * are expected to be non-null.  Element names could
     * be either null or non-null.
     * 
     * @param name1  The name for the first message
     * @param elementName1 The element name for the first message
     * @param name2  The name for the second message
     * @param elementName2 The element name for the second message
     * @return TRUE if there's a match,
     *         FALSE otherwise
     */
    private static boolean matchMessageNames(String name1, String elementName1, String name2,
                                             String elementName2) {
        // the name for the message must exist
        if ((name1 != null) && (name2 != null) && (name1.equals(name2))) {
            // there's a match on the name associated with the message object

            // element names need to match, including being null
            if ((elementName1 == null) && (elementName2 == null)) {
                // there's a match for the nulls
                return true;
            } else if ((elementName1 != null) && (elementName2 != null)
                    && (elementName1.equals(elementName2))) {
                // there's a match for the element names
                return true;
            } else {
                // there's some mismatch
                return false;
            }
        } else {
            // either a message name is null or the names don't match
            return false;
        }
    }

}
