remove current <remoteId,actor> mappings if present.
return map containing removed mappings (for reconnection)
@param act
762502
public void unpublishActor(Actor act) {
        Long integer = publishedActorMappingReverse.get(act.getActorRef());
        if ( integer != null ) {
            Log.Debug(this, ""+act.getClass().getSimpleName()+" unpublished");
            publishedActorMap.remove(integer);
            publishedActorMappingReverse.remove(act.getActorRef());
            act.__removeRemoteConnection(this);
            if ( act instanceof RemotedActor) {
                String connectionIdentifier = getSocketRef().getConnectionIdentifier();
                ((RemotedActor) act).hasBeenUnpublished(connectionIdentifier);
            }
        }
    }
61689
def delete_zombie_actions(self):
        
        id_to_del = []
        for act in list(self.actions.values()):
            if act.status == ACT_STATUS_ZOMBIE:
                id_to_del.append(act.uuid)
        # une petite tape dans le dos et tu t'en vas, merci...
        # *pat pat* GFTO, thks :)
        for a_id in id_to_del:
            del self.actions[a_id]
776880
private void removeMemberships(Node userNode, boolean broadcast) throws RepositoryException
   {
      PropertyIterator refUserProps = userNode.getReferences();
      while (refUserProps.hasNext())
      {
         Node refUserNode = refUserProps.nextProperty().getParent();
         refUserNode.remove();
      }
   }
427751
public void remove(Handle handle)
                    throws RemoteException,
                    RemoveException
    {
        homeEnabled();

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "remove", handle);

        EJBObject ejb = handle.getEJBObject();
        ejb.remove();

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "remove");
    }
508338
protected void remoteRefStopped(Actor actor) {
        removeRemoteActor(actor);
        actor.getActorRef().__stopped = true;
        actor.getActor().__stopped = true;
    }
1289288
public void unmap(final Group group, final Role role)
    {
        this.unmap(role, SesameRealmConstants.OAS_ROLEMAPPEDGROUP, group.getName());
    }
319257
public Set<Integer> removeConnections(String endpointId) {
        Set<Integer> removed = this.entries.removeAll(endpointId);
        if (!removed.isEmpty() && log.isDebugEnabled()) {
            log.debug("Call " + getCallIdHex() + " unregistered connections " + Arrays.toString(convertToHex(removed)) + " from endpoint " + endpointId);
        }
        return removed;
    }
679562
def _unset_required(self):
        
        self._required_args = [act for act in self._actions if act.required]
        for act in self._required_args:
            act.required = False
706551
def remote(self, action):
        
        method = "remote"

        A = None
        metadata = {method: action}

        send_array(self.socket, A, metadata)
        A, metadata = recv_array(
            self.socket, poll=self.poll, poll_timeout=self.poll_timeout,
            flags=self.zmq_flags)

        return metadata[method]
710641
def remove_token(self, act):
        
        if act in self.tokens:
            self.unregister_fd(act)
            del self.tokens[act]
            return True
        else:
            import warnings
            warnings.warn("%s isn't a registered token." % act)
62249
def changed_action(mapper, connection, target):
    """"""
    action_history = get_history(target, 'action')
    argument_history = get_history(target, 'argument')
    owner_history = get_history(
        target,
        'user' if isinstance(target, ActionUsers) else
        'role' if isinstance(target, ActionRoles) else 'role_name')

    if action_history.has_changes() or argument_history.has_changes() \
       or owner_history.has_changes():
        current_access.delete_action_cache(
            get_action_cache_key(target.action, target.argument))
        current_access.delete_action_cache(
            get_action_cache_key(
                action_history.deleted[0] if action_history.deleted
                else target.action,
                argument_history.deleted[0] if argument_history.deleted
                else target.argument)
        )
266183
def remove(self):
        
        LOGGER.debug("InjectorGearSkeleton.remove")
        ret = self.cached_gear_actor.remove().get()
        if self.actor_ref:
            self.stop()
        return ret
821043
public CmsListDefaultAction removeDefaultAction(String actionId) {

        Iterator<CmsListDefaultAction> it = m_defaultActions.iterator();
        while (it.hasNext()) {
            CmsListDefaultAction action = it.next();
            if (action.getId().equals(actionId)) {
                it.remove();
                return action;
            }
        }
        return null;
    }
339573
private void unmapRuleFromAllDataProviders(final R rule) {
        if (rule != null) {
            for (final List<R> mappedRules : dataProvidersToRules.values()) {
                mappedRules.remove(rule);
            }
        }
    }
550983
def __remove_actions(self):
        

        LOGGER.debug("> Removing '{0}' Component actions.".format(self.__class__.__name__))

        send_selection_to_server_action = "Actions|Umbra|Components|addons.tcp_serverUi|&Command|Send Selection To Server"
        send_file_to_server_action = "Actions|Umbra|Components|addons.tcp_serverUi|&Command|&Send Current File To Server"
        for action in (send_selection_to_server_action, send_file_to_server_action):
            self.__script_editor.command_menu.removeAction(self.__engine.actions_manager.get_action(action))
            self.__engine.actions_manager.unregister_action(action)
790189
public void removeTask(AgentTask task) {
		final Iterator<WeakReference<AgentTask>> iterator = this.tasks.iterator();
		while (iterator.hasNext()) {
			final WeakReference<AgentTask> reference = iterator.next();
			final AgentTask knownTask = reference.get();
			if (knownTask == null) {
				iterator.remove();
			} else if (Objects.equals(knownTask.getName(), task.getName())) {
				iterator.remove();
				return;
			}
		}
	}
1251198
public OperationFuture<List<FirewallPolicy>> delete(List<FirewallPolicy> firewallPolicyList) {
        List<JobFuture> jobs = firewallPolicyList
            .stream()
            .map(reference -> delete(reference).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            firewallPolicyList,
            new ParallelJobsFuture(jobs)
        );
    }