Method to indicate the destination is to be deleted.
969324
public void setToBeDeleted()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "setToBeDeleted");

    
    // Tell the remote code the destination is to be deleted
    if (_remoteSupport != null)
      _remoteSupport.setToBeDeleted();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "setToBeDeleted");
  }
667128
private void checkAppExit(Object sender) {
        NavLocation curLocation = navigationManager.getModel().getCurrentLocation();
        if (curLocation == null) {
            navigationManager.postEvent2C(new NavigationManager.Event.OnAppExit(sender));
        }
    }
1128771
public void destroyDestination(Destination d)
	{
		// method invocation is idempotent
		synchronized (proxies) {
			final AggregatorProxy p = (AggregatorProxy) proxies.get(d.getAddress());
			if (p == null)
				return;
			if (p.getDestination() == d) {
				proxies.remove(d.getAddress());
				d.destroy();
			}
			else
				logger.warn("not owner of " + d.getAddress());
		}
	}
1002324
def destination_absent(name, server=None):
    '''
    
    '''
    ret = {'name': name, 'result': None, 'comment': None, 'changes': {}}
    jms_ret = _do_element_absent(name, 'admin_object_resource', {}, server)
    if not jms_ret['error']:
        if __opts__['test'] and jms_ret['delete']:
            ret['comment'] = 'JMS Queue set to be deleted'
        elif jms_ret['delete']:
            ret['result'] = True
            ret['comment'] = 'JMS Queue deleted'
        else:
            ret['result'] = True
            ret['comment'] = 'JMS Queue doesn\'t exist'
    else:
        ret['result'] = False
        ret['comment'] = 'Error: {0}'.format(jms_ret['error'])
    return ret
73048
public boolean cleanupDestination() throws SIRollbackException, SIConnectionLostException, SIIncorrectCallException, SIResourceException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "cleanupDestination");
  
    boolean cleanedUp;

    //Clean up any remote localisations, reallocate messages that are marked as guesses
    cleanedUp = super.cleanupLocalisations();
    //Ensure any cleanup does not occur at the same time the link is being used.
    synchronized(this)
    {        
      if (isToBeDeleted())
      {
        // Clean up any PubSub neighbours that were making use of 
        // the link
        
        messageProcessor.getProxyHandler().cleanupLinkNeighbour(_busName);
        
        // A link can have inbound target stream state without a localisation for
        // the messages to be put onto, as it routes the messages directly onto
        // other destinations in the bus.  Until all the inbound streams are flushed,
        // the link cannot be deleted.
        PtoPInputHandler ptoPInputHandler = (PtoPInputHandler) getInputHandler(ProtocolType.UNICASTINPUT, null, null);
        TargetStreamManager targetStreamManager = ptoPInputHandler.getTargetStreamManager();
        
        if (targetStreamManager.isEmpty())
        {
          cleanedUp = super.cleanupDestination();
        }
      }
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cleanupDestination", new Boolean(cleanedUp));

    return cleanedUp;
  }
498436
protected void handleDelete() {
    ModifiableDBIDs todel = DBIDUtil.newHashSet();
    ModifiableDBIDs remain = DBIDUtil.newHashSet(dbids);
    DBIDArrayIter it = dbids.iter();
    for(int row : table.getSelectedRows()) {
      it.seek(row);
      todel.add(it);
      remain.remove(it);
    }
    // Unselect first ...
    context.setSelection(new DBIDSelection(remain));
    // Now delete them.
    for(DBIDIter iter = todel.iter(); iter.valid(); iter.advance()) {
      database.delete(iter);
    }
  }
1352991
def _do_leave(self, leave, in_port, msg):
        """"""
        datapath = msg.datapath
        parser = datapath.ofproto_parser

        self._mcast.setdefault(leave.address, {})
        if in_port in self._mcast[leave.address]:
            self._del_flow_entry(
                datapath, in_port, leave.address)
            del self._mcast[leave.address][in_port]
            actions = []
            for port in self._mcast[leave.address]:
                actions.append(parser.OFPActionOutput(port))
            if len(actions):
                self._set_flow_entry(
                    datapath, actions, self.server_port, leave.address)
            else:
                self._del_flow_entry(
                    datapath, self.server_port, leave.address)
161346
public void markDestinationAsCleanUpPending(DestinationHandler dh)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "markDestinationAsCleanUpPending", dh);

        if (dh.isLink())
        {
            linkIndex.cleanup(dh);
        }
        else
        {
            destinationIndex.cleanup(dh);
        }

        //Start asynchDeletionThread if not already running
        startAsynchDeletion();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "markDestinationAsCleanUpPending");
    }
946015
public void setDestination(DestinationHandler originalDestination)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setDestination", originalDestination);

        _originalDestination = originalDestination;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setDestination");
    }
677470
public void markVisited(int from, int upTo) {
    if (checkBounds(from) && checkBounds(upTo - 1)) {
      for (int i = from; i < upTo; i++) {
        this.markVisited(i);
      }
    }
    else {
      throw new RuntimeException("The location " + from + "," + upTo + " out of bounds [0,"
          + (this.registry.length - 1) + "]");
    }
  }
1148371
@Override
    public void setDestination(Destination destination) {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setDestination", destination);
        }
        _destination = destination;
    }
847275
@Override
    public void deleteSystemDestination(String prefix)
                    throws SINotPossibleInCurrentConfigurationException,
                    SIException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "deleteSystemDestination", prefix);
        // See if this connection has been closed
        checkNotClosed();

        _destinationManager.deleteSystemDestination(
                        SIMPUtils.createJsSystemDestinationAddress(prefix,
                                                                   _messageProcessor.getMessagingEngineUuid()));
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "deleteSystemDestination");
    }
924795
public void initiateCleanUp(String destinationUuid)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "initiateCleanUp", destinationUuid);

    DestinationHandler destinationHandler = null;

    try
    {
      destinationHandler = destinationManager.getDestination(new SIBUuid12(destinationUuid), true);
    }
    catch (SINotPossibleInCurrentConfigurationException e)
    {
      // No FFDC code needed
      //do nothing            
    } 
    catch (SITemporaryDestinationNotFoundException e)
    {
      // No FFDC code needed 
      //do nothing            
    }   
    
    if (destinationHandler != null)
    {
      destinationManager.markDestinationAsCleanUpPending(destinationHandler);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "initiateCleanUp");
      
    return;
  }
993278
protected void onFoundDestination (String destName) {
        if ( ( destName != null ) && ( ! destName.isEmpty() ) ) {
            DestinationState destState =
                    this.registry.putIfAbsent(destName, new DestinationState(destName, this.brokerId));

            //
            // If it was already there, mark it as seen now by the broker.
            //
            if ( destState != null ) {
                destState.putBrokerInfo(this.brokerId, true);
            }
        }
    }
1067841
public synchronized void remove(Entry entry)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove", new Object[] { entry });

    super.remove(entry);
    DestinationHandler dh = (DestinationHandler) entry.data;
    HashMap<String, Entry> busMap = getBusMap(dh.getBus());
    DestinationEntry destEntry = (DestinationEntry) busMap.get(dh.getName());
    if(destEntry == entry)
    {
      busMap.remove(dh.getName());
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove");
  }
947529
function(source, destination, failIfExists) {
    this.source = source;
    this.destination = destination;
    this.failIfExists = failIfExists ? failIfExists : false;
}
344237
def _notify_remove_at(self, index, length=1):
        """"""
        slice_ = self._slice_at(index, length)
        self._notify_remove(slice_)