On deleted method
187180
def on_deleted(self, event):
        """"""
        for delegate in self.delegates:
            if hasattr(delegate, "on_deleted"):
                delegate.on_deleted(event)
1281489
protected function onBeforeDelete()
    {
        $this->brokenOnDelete = false;

        $dummy = null;
        $this->extend('onBeforeDelete', $dummy);

        // Cascade deletes
        $deletes = $this->findCascadeDeletes(false);
        foreach ($deletes as $delete) {
            $delete->delete();
        }
    }
1152943
def on_deleted(self, event):
        
        key = 'filesystem:file_deleted'
        data = {
            'filepath': event.src_path,
            'is_directory': event.is_directory,
            'dirpath': os.path.dirname(event.src_path)
        }

        bmsg = BroadcastMessage(key=key, data=data)
        BroadcastManager.broadcast(bmsg)
783609
function onDialogDelete() {
    if (confirm('Are you sure you want remove the dialog?')) {
        QB.chat.dialog.delete(currentDialog._id, function(err, res) {
            if (err) {
                console.error(err);
            } else {
                console.info('Dialog removed');
            
                $('#'+currentDialog._id).remove();
                delete dialogs[currentDialog._id];

                if(Object.keys(dialogs).length > 0){
                    triggerDialog(dialogs[Object.keys(dialogs)[0]]._id);
                } else {
                    $('#messages-list').empty();
                }
            }
        });

        $("#update_dialog").modal("hide");
        $('#update_dialog .progress').show();
    }
}
1264400
def model_deleted(sender, instance,
                          using,
                          **kwargs):
    
    opts = get_opts(instance)
    model = '.'.join([opts.app_label, opts.object_name])
    distill_model_event(instance, model, 'deleted')
1213449
public static void fireDeleted(Run r) {
        for (RunListener l : all()) {
            if(l.targetType.isInstance(r))
                try {
                    l.onDeleted(r);
                } catch (Throwable e) {
                    report(e);
                }
        }
    }
365
def delete(self, **params):
        """"""
        d = self.request('delete', self.instance_url(), params)
        return d.addCallback(self.refresh_from).addCallback(lambda _: self)
609732
def on_moved(self, event):
        
        self.on_deleted(events.FileDeletedEvent(event.src_path))
        self.on_created(events.FileCreatedEvent(event.dest_path))
861526
private void onDelete(EventLog log)
    {
        if (deleteEvents == null)
        {
            deleteEvents = new ConcurrentHashMap<Object, EventLog>();
        }

        deleteEvents.put(log.getEntityId(), log);

    }
1270923
@InterfaceAudience.Public
    public boolean isDeletion() {
        Object deleted = getProperty("_deleted");
        if (deleted == null) {
            return false;
        }
        Boolean deletedBool = (Boolean) deleted;
        return deletedBool.booleanValue();
    }
20773
function onDeleteSuccess(model, params, result) {
  Flux.dispatch(actionTypes.API_DELETE_SUCCESS, {
    model: model,
    params: params,
    result: result,
  })
  return result
}
372386
public void doRemove() throws DBException
    {
        super.doRemove();
        if (m_arrayCache != null)
            if (m_iLogicalIndex != -1)
                m_arrayCache.set(m_iLogicalIndex, null);    // Show the current record as deleted.
    }
647640
@Override
    public void doExecute() {
        if (!getEditor().isReadOnly()) {
            deleted = getEditor().delete().charAt(0);
            if (Character.isLetter(deleted) && Character.isLowerCase(deleted)) {
                getEditor().put(deleted.toString().toUpperCase());
                getEditor().moveLeft(1);
            } else {
                if (Character.isLetter(deleted) && Character.isUpperCase(deleted)) {
                    getEditor().put(deleted.toString().toLowerCase());
                    getEditor().moveLeft(1);
                }
            }
        }
    }
879003
protected void onRemoved() {
        List<TransformerChangeListener> listeners = getAllListeners();
        for (TransformerChangeListener listener : listeners) {
            listener.onOutputChanged(this, new LinkedList<MutableInputColumn<?>>());
            listener.onRemove(this);
        }
    }
1175784
def delete(self, data=None):
        """"""
        if not self.can_delete:
            raise JSSMethodNotAllowedError(self.__class__.__name__)
        if data:
            self.jss.delete(self.url, data)
        else:
            self.jss.delete(self.url)
1170770
def ndeleted(self):
        """"""
        if not self._counters_calculated:
            self._counters_calculated = True
            self._extract_counters()

        return self._ndeleted
508656
public void entryRemoved (EntryRemovedEvent<T> event)
    {
        dispatchMethod(event.getName() + "Removed",
            new Object[] { event.getKey() });
    }