Concrete method of Subject.register().
        Register observers as an argument to self.observers.
426588
def register(self, observers):
        

        if isinstance(observers, list) or isinstance(observers, tuple):

            for observer in observers:
                # check whether inhelitance "base.Observer"
                if isinstance(observer, base.Observer):
                    self._observers.append(observer)

                else:
                    raise InhelitanceError(base.Observer.__name__)

        elif isinstance(observers, base.Observer):
            self._observers.append(observers)
958902
def register_subscriber(topic, topic_type)
      code, message,val = @proxy.registerSubscriber(@caller_id,
                                                    topic,
                                                    topic_type,
                                                    @slave_uri)
      if code == 1
        val
      elsif code == 0
        puts message
        val
      else
        raise message
      end
    end
623371
def register_instance(self, class_type, instance, register_as=None):
        
        registration = _InstanceRegistration(instance)
        self._register(class_type, registration, register_as)
123000
@Override
	public synchronized void registerObserver(SubjectObserver<Settings> settingsObserver)
	{
		if (settingsObserver == null)
			throw new IllegalArgumentException("settingsObserver is required");
		
		if(file != null)
		{
			if(fileMonitor == null)
				fileMonitor = new FileMonitor();				
			
			fileMonitor.monitor(file.getParent(), file.getName(), false);
			//Observer fileEventBridge = (observable,o) -> {this.reLoad();};
			//fileMonitor.addObserver(fileEventBridge);
			fileMonitor.add((observable,o) -> this.reLoad());
		}
		
		registry.register(getClass().getName(), settingsObserver);
	}
1048784
def add_observer(self, observer):
        
        if not isinstance(observer, PowerManagementObserver):
            raise TypeError("observer MUST conform to power.PowerManagementObserver")
        self._weak_observers.append(weakref.ref(observer))
987712
def register(self, event, callable, priority=10):
        """"""
        logger.debug('registered: ' + event + ': ' + repr(callable) + ' [' + repr(self) + ']')
        return EventReceiver(event, callable, manager=self, priority=priority)
883894
def set_register(self, register, value):
        
        context = self.get_context()
        context[register] = value
        self.set_context(context)
716943
def addObserver(self, observer):
        
        with self._lock:
            self._weak_observers.append(weakref.ref(observer))
            if len(self._weak_observers) == 1:
                self.startThread()
1318482
def register(self, *args, **kwargs):
    """"""
    if self._frozen:
      raise FrozenRegistration(self.scope, args[0])

    # Prevent further registration in enclosing scopes.
    ancestor = self._parent_parser
    while ancestor:
      ancestor._freeze()
      ancestor = ancestor._parent_parser

    if kwargs.get('type') == bool:
      default = kwargs.get('default')
      if default is None:
        # Unless a tri-state bool is explicitly opted into with the `UnsetBool` default value,
        # boolean options always have an implicit boolean-typed default. We make that default
        # explicit here.
        kwargs['default'] = not self._ensure_bool(kwargs.get('implicit_value', True))
      elif default is UnsetBool:
        kwargs['default'] = None

    # Record the args. We'll do the underlying parsing on-demand.
    self._option_registrations.append((args, kwargs))
    if self._parent_parser:
      for arg in args:
        existing_scope = self._parent_parser._existing_scope(arg)
        if existing_scope is not None:
          raise Shadowing(self.scope, arg, outer_scope=self._scope_str(existing_scope))
    for arg in args:
      if arg in self._known_args:
        raise OptionAlreadyRegistered(self.scope, arg)
    self._known_args.update(args)
850747
def register(model, field_name=None, related_name=None, lookup_method_name='get_follows'):
    
    if model in registry:
        return

    registry.append(model)
    
    if not field_name:
        field_name = 'target_%s' % model._meta.module_name
    
    if not related_name:
        related_name = 'follow_%s' % model._meta.module_name
    
    field = ForeignKey(model, related_name=related_name, null=True,
        blank=True, db_index=True)
    
    field.contribute_to_class(Follow, field_name)
    setattr(model, lookup_method_name, get_followers_for_object)
    model_map[model] = [related_name, field_name]
274738
def register_watchers(self, type_callback_dict, register_timeout=None):
        
        for event_type, callback in type_callback_dict.items():
            self._push_watchers[event_type].add(callback)
        self.wait_for_response(
            RegisterMessage(event_list=type_callback_dict.keys()),
            timeout=register_timeout)
140282
def add_observer(self, observer, callble, priority=0):
        
        self.observers.add(priority, observer, callble)
361595
def register(subject, schema, **params)
      lookup_subject_schema(subject, schema)
    rescue Excon::Errors::NotFound
      register_without_lookup(subject, schema, params)
    end
648929
def register(cls, config={}):
        
        if cls.accessor is not None:
            if cls.instance is None:
                cls.instance = cls.accessor(config)
63365
def register(self, receiver_id, receiver):
        """"""
        assert receiver_id not in self.receivers
        self.receivers[receiver_id] = receiver(receiver_id)
718899
public void register(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			Method[] methods = clazz.getMethods();
			for (Method m : methods) {
				if (!m.isAnnotationPresent(Subscribe.class)) continue;
				Class[] params = m.getParameterTypes();

				if (params.length != 1)
					throw new IllegalArgumentException("Method " + m + " has @Subscribe annotation" +
							"and requires " + params.length +
							" arguments, but event-handling methods must require just one argument");
				Class event = params[0];
				EventHandler handler = new EventHandler(listener, m);
				this.handlersByEventType.put(event, handler);
			}
		}
	}
1301941
private function registerObserver()
    {
        if ($this->observer) {
            return;
        }

        $this->observer = new \chilimatic\lib\session\observer\Session($this);
        $this->engine->attach($this->observer);
    }