Register the breakpoint of the name. Usage:
        > breakpoint('setup-done')

        The name should be used in a call of Driver.register_breakpoint(name)
        method, which returns the Deferred, which will be fired by this
        command.
180115
def breakpoint(self, name):
        
        if name not in self._breakpoints:
            self.warning("Reached breakpoint %s but found no "
                         "callback registered")
            return
        cb = self._breakpoints[name]
        cb.callback(None)
        return cb
312893
function ( name )
	{
		var breakpoints = this.c.breakpoints;

		for ( var i=0, ien=breakpoints.length ; i<ien ; i++ ) {
			if ( breakpoints[i].name === name ) {
				return breakpoints[i];
			}
		}
	}
145263
def debug(self, debug):
        

        yield from self._hypervisor.send("nio set_debug {name} {debug}".format(name=self._name, debug=debug))
933966
def register(transition)
      event_type = transition.class.instance_variable_get(:@event_type)
      event_trigger_value = transition.event_trigger_value

      transition_map[event_type] ||= {}

      transitions =
        (transition_map[event_type][event_trigger_value] ||= [])
      transitions << transition

      transition
    end
714267
def setBreakpoints( self, breakpoints ):
        
        self.clearBreakpoints()
        for breakpoint in breakpoints:
            self.addBreakpoint(breakpoint)
470634
def init_wait_register(self):
        
        app = self.config.get("application")

        if app:
            bef_init_cmds = app.get("cli_ready_trigger")
            if bef_init_cmds:
                self.init_done.clear()
                self.init_event_matcher = EventMatcher(EventTypes.DUT_LINE_RECEIVED,
                                                       bef_init_cmds, self, self.init_done)
                self.init_wait_timeout = app.get("cli_ready_trigger_timeout", 30)
                return
        self.init_done.set()
        return
898001
def register_plugin(self, name, plugin):
        
        if self.has_plugin(name):
            self.release_plugin(name)
        self._active_plugins[name] = plugin
        setattr(self, name, plugin)
        return plugin
13497
def register(name, func=None):
    

    def decorator(func):
        # Perform the registration
        ControlDaemon._register(name, func)
        return func

    # If func was given, call the decorator, otherwise, return the
    # decorator
    if func:
        return decorator(func)
    else:
        return decorator
1190771
def _register(self, name):
        
        templatehook = TemplateHook()
        self._registry[name] = templatehook
        return templatehook
427959
function registerDriver(Driver, name, options) {
  if (this.drivers[name]) {
    log.error(new Error('Driver "' + name + '" is already registered.'));
    return;
  }
  if (!Driver || !Driver.prototype || typeof Driver.prototype.send !== 'function') {
    log.error(new Error('Driver "' + name + '" should implement "send" method.'));
    return;
  }
  this.drivers[name] = new Driver(options || {});
}
904433
def register_scope(self, name: str, scope_class: Type[Scope]) -> None:
        
        with self._lock:
            if name in self.scopes:
                raise AlreadyConfigured(f'Scope {name} already registered')
            self.scopes[name] = scope_class()
1060984
def setup_resume(self):
        
        self.frame_calling = None
        self.frame_stop = None
        self.frame_return = None
        self.frame_suspend = False
        self.pending_stop = False
        if not IKBreakpoint.any_active_breakpoint:
            self.disable_tracing()
        return
1057545
def register(self, request_class: Request, handler_factory: Callable[[], Handler]) -> None:
        
        key = request_class.__name__
        is_command = request_class.is_command()
        is_event = request_class.is_event()
        is_present = key in self._registry
        if is_command and is_present:
            raise ConfigurationException("A handler for this request has already been registered")
        elif is_event and is_present:
            self._registry[key].append(handler_factory)
        elif is_command or is_event:
            self._registry[key] = [handler_factory]
46639
def break_name(self, break_name):
        

        if break_name is None:
            raise ValueError("Invalid value for `break_name`, must not be `None`")
        if len(break_name) < 1:
            raise ValueError("Invalid value for `break_name`, length must be greater than or equal to `1`")

        self._break_name = break_name
703957
def entry_point(entry_point_name):
    
    def wrap(f):
        ENTRY_POINT_TABLE[entry_point_name] = f
        @wraps(f)
        def wrapped_f(*args, **kwargs):
            return f(*args, **kwargs)
        return wrapped_f
    return wrap
838071
def register(self, callback, name):
        ''
        server.CALLBACKS[name] = callback
        self.run('''
            window.skink.%s = function(args=[]) {
                window.skink.call("%s", args);
            }''' % (name, name))
655024
def setup_queue(self, queue_name):
        
        logger.info('Declaring queue', name=queue_name)
        self._channel.queue_declare(
            self.on_queue_declareok, queue_name, durable=self._durable_queue
        )