Execute all the registered afterFilters for the current action
513567
public function afterFilter() {
        if(!isset($this->_afterFilters[$this->_action])) {
            return false;
        }

        foreach($this->_afterFilters[$this->_action] as $method) {
            call_user_func($method);
        }
    }
303559
def do_actions(self, target_filename, dry_run=False):
        
        for rule in self.action_rules:
            target_filename = rule.do_action(target_filename, dry_run)

        raise StopProcessingException
493338
private function runHooks()
    {
        if (class_exists($Hook = 'Josantonius\Hook\Hook')) {
            $Hook::getInstance(self::$id);
            if (isset($this->settings['hooks'])) {
                $Hook::addActions($this->settings['hooks']);
                unset($this->settings['hooks']);
            }
            $Hook::doAction('after-load-hooks');
        }
    }
360172
def execute(self, return_results=True):
        '''
        
        '''
        if self.results:
            return self.results if return_results else None

        self.execute_raw()

        if self._raw_results_only:
            self.results = self.raw_results
        else:
            self.map_results()

        if return_results:
            return self.results
1163852
function executePipeOnDestroys(viewData) {
    var pipeDestroyHooks = viewData[TVIEW] && viewData[TVIEW].pipeDestroyHooks;
    if (pipeDestroyHooks) {
        callHooks(viewData, pipeDestroyHooks);
    }
}
933076
function() {
    var self = this;
    var fsm = self.filterStateModel;

    var newFilter = fsm.get("filterCollection").createNewFilter();
    fsm.set("activeFilterId", newFilter.cid);

    self.trigger("filter:new", newFilter.cid, newFilter);
  }
335172
def execute(self, requests, resp_generator, *args, **kwargs):
        '''
            
        '''
        return [resp_generator(request) for request in requests]
1317706
public function afterFilter(Event $event)
    {
        $pluginEvent = Plugin::getData('Core', 'Controller.afterFilter');
        if (is_callable($pluginEvent->find(0)) && Plugin::hasManifestEvent('Controller.afterFilter')) {
            call_user_func_array($pluginEvent->find(0), [$this, $event]);
        }
    }
178002
function getFilterMethods(type, controller, action) {
  // Get all filters for the action.
  let filters = getFilters(type, controller, action)
  // Get filter method names to be skipped.
  type = `skip${type[0].toUpperCase() + type.slice(1)}`
  let skipFilterMethods = _.map(getFilters(type, controller, action), 'action')

  // Remove filters that should be skipped.
  filters = _.filter(filters, f => {
    for(let method of skipFilterMethods)
      if(method === f.action)
        return false
    return true
  })

  // Return final list of filter methods.
  return _.map(filters, f => {
    let { action } = f
    action = typeof action === 'string' ? controller[action] : action
    return action.bind(controller)
  })
}
1018644
def action_filter(method_name, *args, **kwargs):
    

    def action_filter(value, context, **_params):
        method = getattr(context["action"], method_name)
        return _filter(method, value, args, kwargs)

    return action_filter
982489
function() {
    var self = this;
    var currentFilter = self.filterStateModel.getActiveFilter();
    var stateBeforeCancel = {
      name: currentFilter.get("name"),
      attributeFilters: currentFilter.get("attributeFilters") ? currentFilter.get("attributeFilters").toJSON() : null
    };

    currentFilter.cancelFilter();

    self.trigger("filter:cancel", currentFilter.cid, currentFilter, stateBeforeCancel);
  }
1072237
async def execute_filter(filter_: FilterObj, args):
    
    if filter_.is_async:
        return await filter_.filter(*args, **filter_.kwargs)
    else:
        return filter_.filter(*args, **filter_.kwargs)
378235
def _execute_rules(self, matches, context):
        
        if not self.disabled(context):
            rules = self.effective_rules(context)
            rules.execute_all_rules(matches, context)
746206
public static void after(String path, String acceptType, Filter... filters) {
        for (Filter filter : filters) {
            getInstance().after(path, acceptType, filter);
        }
    }
922576
def _filtered_actions(self, *a_types):
        
        for a in filter(lambda _: self.is_action(_, *a_types), self._actions):
            yield a
205182
public void afterAfter(Filter filter) {
        addFilter(HttpMethod.afterafter, FilterImpl.create(SparkUtils.ALL_PATHS, filter));
    }
337075
@Override
    protected void onFilteredApplicationEvent(ApplicationEvent event) {
        if (this.eventLogger.isInfoEnabled()) {
            this.eventLogger.info(event.toString());
        }
    }