Runs the function associated with the given entry `name`.
544170
def run(self, name):
        """"""
        for entry in self.entries:
            if entry.name == name:
                run_func(entry)
                break
220840
def action(name, altname=nil, &block) 
      Runner.instance.add_action name, altname, &block
    end
867568
def call(self, name: str, *args, **kwargs):
        ''''''
        if self._event_dispatcher is not None:
            self._event_dispatcher.notify(name, *args, **kwargs)

        if self._callbacks[name]:
            return self._callbacks[name](*args, **kwargs)
        else:
            raise HookDisconnected('No callback is connected.')
1018375
public void create_function( String name, int nargs, Function f ) {
        synchronized (this) {
            _create_function(name, nargs, f);
        }
    }
1361406
def call(self, name, *a):
        """"""
        return callJavaFunc(self._sc, getattr(self._java_model, name), *a)
849857
def run(self, f, *args, **kwargs):
        
        parent = _ACTION_CONTEXT.set(self)
        try:
            return f(*args, **kwargs)
        finally:
            _ACTION_CONTEXT.reset(parent)
1083135
public static function runHook($name, array $params = [ ])
    {
        static::ensureHookPoint($name);

        foreach (static::$hooks[ $name ] as $handler) {
            if ($handler instanceof \Closure) {

                call_user_func_array($handler, $params);
            } elseif (class_exists($handler)) {
                $instance = app()->make($handler);

                call_user_func_array([ $instance, 'handle' ], $params);
            }
        }
    }
1341645
def execute_notebook(self, name):
        """"""

        warnings.filterwarnings("ignore", category=DeprecationWarning)
        nb,f = self.load_notebook(name)
        self.run_notebook(nb,f)
        self.assertTrue(True)
1166708
def run(*args, **kwargs):
    '''
    
    '''
    lib = sys.modules[asynclib.lib_name]
    lib.run(*args, **kwargs)
254768
function _run(init, rules, namespace) {
    const size = _size();
    let evts = rules || events;
    let	i;

    // If breakpoint has been hit or resize logic initialized
    if (size && (init || size !== current)) {
        if (namespace) {
            evts = evts.filter(obj => obj.namespace === namespace);
        }

        i = evts.length;

        while (i--) {
            const evt = evts[i];

            if (_eq(evt, size, init)) {
                const f = init && ! current;
                const data = {
                    dir: f ? 0 : (size > current ? 1 : -1),
                    init: f,
                    prev: current,
                    size,
                };

                $exec(evt.callback, {
                    args: evt.args ? [data].concat(evt.args) : [data],
                    scope: evt.scope,
                });

                // Disable future execution if once
                if (evt.once) {
                    events = events.filter(obj => obj.i !== evt.i);
                }
            }
        }

        // Cache current value
        current = size;
    }
}
642719
function(name)
{
  //Check if the queue exists
  if(typeof tasks[name] !== 'object'){ return; }

  //Check if queue is paused
  if(tasks[name].paused === true)
  {
    //Set task queue running false
    tasks[name].running = false;
  }
  else
  {
    //Set queue running
    tasks[name].running = true;

    //Check the number of tasks on this tag
    if(tasks[name].handlers.length === 0)
    {
      //Delete this path object
      delete tasks[name];
    }
    else
    {
      //Get the function to run
      var handler = tasks[name].handlers.shift();

      //Run this task
      return handler.call(null, function()
      {
        //Continue with the next task
        return process.nextTick(function()
        {
          //Continue with the next task in the queue
          return task_run(name);
        });
      });
    }
  }
}
1366942
def run_on(*, event: str):
        """"""

        def decorator(callback):
            @functools.wraps(callback)
            def decorator_wrapper():
                RTMClient.on(event=event, callback=callback)

            return decorator_wrapper()

        return decorator
181211
static
	public void putFunction(String name, Function function){
		FunctionRegistry.functions.put(Objects.requireNonNull(name), function);
	}
233094
def bind_key_name(self, function, object_name):
        """"""
        for funcname, name in self.name_map.items():
            if funcname == function:
                self.name_map[
                    funcname] = object_name
1251200
def run(self):
        """"""
        while not self._finished.isSet():
            self._func(self._reference)
            self._finished.wait(self._func._interval / 1000.0)
81836
def run_hook(hook_name, *args, &block)
      hooks.find {|hook| hook.name == hook_name }.run(self, *args, &block)
    end
815832
function(name, count, out){
			if(out[name]){
				out[name] = out[name] + count;
			}else{
				out[name] = count;
			}
		}