docs: void handleResetState(SubscriptionMessage resetMessage, 
        Transaction transaction,
                          boolean request)
      throws SIException
    {
      if (tc.isEntryEnabled()) 
        SibTr.entry(tc, "handleResetState", 
          new Object[]{resetMessage, transaction, new Boolean(request)});
      
      boolean foreignTemporaryProxy = false;
      // Flag for securing foreign proxy subs
      boolean foreignAllowed = true;
      // Userid to be stored when securing foreign proxy subs
      String MESubUserId = null;
      // Flag to indicate whether a proxy sub originated from
      // a foreign bus where the home bus is secured.
      boolean foreignSecuredProxy = false;
          
      // Get the iterators that we require for this method
      final Iterator topics = resetMessage.getTopics().iterator();
      final Iterator topicSpaces = resetMessage.getTopicSpaces().iterator();
      final Iterator topicSpaceMappings = resetMessage.getTopicSpaceMappings().iterator();
  
      // Get the Me name and ME uuid
      final byte[] meUUIDArr = resetMessage.getMEUUID();
      final SIBUuid8 meUUID = new SIBUuid8(meUUIDArr);
  
      // Get the Bus that this message arrived from
      final String busId = resetMessage.getBusName();
  
      // Get the Neighbour from the above details
      Neighbour neighbour = iNeighbours.getNeighbour(meUUID);
      
      // If the neighbour is null, then create the Neighbour.
      if (neighbour == null)
      {   
        iProxyHandler.getLockManager().lockExclusive();
  
        try
        {          
          // Create the Neighbour
          iProxyHandler.createNeighbour(meUUID, busId, transaction);
  
          if (tc.isDebugEnabled()) 
            SibTr.debug(tc, "Created Messaging Engine " + meUUID + " on bus " + busId );
            
          neighbour = iNeighbours.getNeighbour(meUUID);
          
          if (!request)
          {
            neighbour.sendRequestProxySubscriptions();          
          }
        }
        catch (SIException e)
        {
          // FFDC
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.proxyhandler.NeighbourProxyListener.handleResetState",
            "1:468:1.73",
            this);
            
          if (tc.isEventEnabled())
            SibTr.exception(tc, e);
          
          if (tc.isEntryEnabled())
            SibTr.exit(tc, "handleResetState", "Unable to create Neighbour so exiting");
          return;
        }
        finally
        {
          iProxyHandler.getLockManager().unlockExclusive();       
        }
      }
      
      // Check if the neighbour had had a request sent to it
      if (neighbour.wasProxyRequestSent())
      {
        // Remove the alarm for this neighbour.
        neighbour.setRequestedProxySubscriptionsResponded();
      }
  
      boolean okToForward = false;
  
      // If the length of the buses are more than one 
      // then that indicates that this subscription is in more then one bus.
      // This subscription is then required to be forwarded onto all Neighbours in 
      // the other buses.
      if (iNeighbours.getAllBuses().length > 1)
      {
        okToForward = true;
  
        // Clear the Array Lists needed.
        iAddTopics.clear();
        iAddTopicSpaces.clear();
        iAddTopicSpaceMappings.clear();
        iDeleteTopics.clear();
        iDeleteTopicSpaces.clear();
      }
  
      // Mark all the current subscriptions from this Neighbour
      neighbour.markAllProxies();
  
      // Cycle through each of the new topics.
      while (topics.hasNext())
      {
        // Get the parameters for this iteration
        final String topic = (String) topics.next();
        //as we are receiving this from a remote ME, the foreign topic
        //space name is actually our own topic space name.
        String topicSpaceName = (String) topicSpaceMappings.next();
        //see defect 267686:
        //This will be the topic space uuid if the subscription is coming
        //from another ME on the same bus. Otherwise it will be the foreign
        //topic space name from this ME's perspective.
        String foreignTopicSpaceName = (String)topicSpaces.next();
        
        //the uuid for our local topic space
        SIBUuid12 localTopicSpaceUuid = null; 
        
        foreignTemporaryProxy = false;
        foreignAllowed = true;
        MESubUserId = null;
        foreignSecuredProxy = false;
        
        // If this message originated from a foreign bus then convert the
        // topicSpaceName to a uuid
        if (!busId.equals(iProxyHandler.getMessageProcessor().getMessagingEngineBus()))
        {
          DestinationHandler topicSpace = 
            iDestinationManager.getDestination(topicSpaceName, false);
                        
          if (topicSpace == null)
          {
            // We do not register temporary proxies for foreign buses.
            // Instead the situation is handled with the request message code.  
            // So we ignore the message
            foreignTemporaryProxy = true;
          }
          else 
          {
            // Check whether bus security is enabled 
            if (iProxyHandler.getMessageProcessor().isBusSecure()) 
            {
              // Check authority to produce to destination
              try 
              {
                if(resetMessage.isSecurityUseridSentBySystem())
                {
                  // Message is from a foreign bus but still retains
                  // SIBServerSubject. This implies that no link inbound
                  // userid was set and we'll allow processing to continue
                  // without the necessity of access checks.                            
                }
                else
                {                            
                  // Get the userid against which to check access.
                  // This userid will also be stored in the MESubscription
                  MESubUserId = resetMessage.getSecurityUserid();
                  foreignAllowed =
                    checkDestinationAccess(topicSpace,
                                           topic,
                                           MESubUserId);
                  foreignSecuredProxy = foreignAllowed;
                }
              } 
              catch (SIException e) 
              {
                // No FFDC code needed
                if (tc.isDebugEnabled())
                  SibTr.debug(tc, "Caught exception " + e);
                foreignAllowed = false;
              }
            }
  
            if (foreignAllowed)
            {
              //we have located our local dest handler for
              //our local topic space for this subscription, so we can 
              //obtain the uuid
              localTopicSpaceUuid = topicSpace.getUuid();
            }          
          }
        } 
        else
        {
          //see defect 267686:
          //we are on the same bus as the subscribing ME - this means that
          //the foreignTopicSpace is actually the local topic space's uuid
          localTopicSpaceUuid = new SIBUuid12(foreignTopicSpaceName);
        }
          
  
        if (!foreignTemporaryProxy && foreignAllowed) 
        {
          // Remove the proxy to this topic
          final MESubscription subscription = 
            neighbour.proxyRegistered(localTopicSpaceUuid,
                                      topicSpaceName,
                                      topic,
                                      foreignTopicSpaceName,
                                      transaction,
                                      foreignSecuredProxy,
                                      MESubUserId);
                                      
          // If the proxy was registered and there are other Neighbours
          // that we can forward this message onto, then add the topic
          // to the list of topics to be forwarded.
          if (subscription!=null)
          {
            // This is a created proxy, so create the PubSubHandler and 
            // assign to the match space.
            final boolean proxyCreated = 
              iNeighbours.createProxy(
                neighbour,
                iDestinationManager.getDestinationInternal(localTopicSpaceUuid, false),
                subscription,
                localTopicSpaceUuid, 
                topic,
                false);
            
            if (proxyCreated && okToForward)
            {
              // Add to the list of topics to forward
              iAddTopics.add(topic);
              iAddTopicSpaces.add(localTopicSpaceUuid);
              iAddTopicSpaceMappings.add(foreignTopicSpaceName);
            }
          }
        }
      }
  
      // Tell the Neighbour to remove all subscriptions that aren't needed 
      // any more
      neighbour.sweepMarkedProxies(
        iDeleteTopicSpaces,
        iDeleteTopics,
        transaction,
        okToForward);
  
      // Forward the deletions onto the other connected Neighbours
      if (okToForward && iDeleteTopics.size() > 0)
      {
        iProxyHandler.unsubscribeEvent(
          iDeleteTopicSpaces,
          iDeleteTopics,      
          busId,
          transaction);
      }
  
      // Forward the creations onto the other connected Neigbours
      if (okToForward && iAddTopics.size() > 0)
      {
        iProxyHandler.subscribeEvent(iAddTopicSpaces, iAddTopics, busId, transaction);
      }
      
      if (request)
        neighbour.sendReplyMessage();
  
      if (tc.isEntryEnabled())
        SibTr.exit(tc, "handleResetState");
    }