Registers the patches.

        :return: Method success.
        :rtype: bool
505660
def register_patches(self):
        

        if not self.__paths:
            return False

        unregistered_patches = []
        for path in self.paths:
            for file in foundations.walkers.files_walker(path, ("\.{0}$".format(self.__extension),), ("\._",)):
                name = foundations.strings.get_splitext_basename(file)
                if not self.register_patch(name, file):
                    unregistered_patches.append(name)

        if not unregistered_patches:
            return True
        else:
            raise umbra.exceptions.PatchRegistrationError(
                "{0} | '{1}' patches failed to register!".format(self.__class__.__name__,
                                                                 ", ".join(unregistered_patches)))
3467
def register(self, func, *args, **kwargs):
        
        self._open[-1].append(UndoOperation(func, *args, **kwargs))
        if not (self._undoing or self._redoing):
            self._redo = []
        self.notify()
62314
def register_patch(self, name, path):
        

        patch = foundations.strings.get_splitext_basename(path)
        LOGGER.debug("> Current patch: '{0}'.".format(patch))

        directory = os.path.dirname(path)
        not directory in sys.path and sys.path.append(directory)

        module = __import__(patch)
        if hasattr(module, "apply") and hasattr(module, "UID"):
            self.__patches[name] = Patch(name=name,
                                         path=path,
                                         module=module,
                                         apply=getattr(module, "apply"),
                                         uid=getattr(module, "UID"))
        else:
            raise umbra.exceptions.PatchInterfaceError(
                "{0} | '{1}' is not a valid patch and has been rejected!".format(self.__class__.__name__, patch))
        return True
443704
def register_callbacks(self, on_create, on_modify, on_delete):
        
        self.on_create = on_create
        self.on_modify = on_modify
        self.on_delete = on_delete
400799
def start(self):
        """"""
        result = self.__enter__()
        self._active_patches.add(self)
        return result
587063
function onPatchesDerive() {
		var patches = this.patches;
		this.patches = [];
		queues.enqueueByQueue(this.handlers.getNode([]), this.currentList, [patches, this.currentList], null,["Apply patches", patches]);
	}
901923
def autoregister(self, cls):
        

        params = self.get_meta_attributes(cls)
        return self.register(cls, params)
299354
def registerAddonModule(cls, module):
        
        prop = '_{0}__addon_modules'.format(cls.__name__)
        mods = getattr(cls, prop, set())
        mods.add(module)
        setattr(cls, prop, mods)
605969
def register(linter):
    
    # add all of the checkers
    register_checkers(linter)

    # register any checking fiddlers
    try:
        from pylint_django.augmentations import apply_augmentations
        apply_augmentations(linter)
    except ImportError:
        # probably trying to execute pylint_django when Django isn't installed
        # in this case the django-not-installed checker will kick-in
        pass

    if not compat.LOAD_CONFIGURATION_SUPPORTED:
        load_configuration(linter)
1103549
def patch(self, instance, errors):
        
        if errors:
            return self.errors(errors)
        return self.updated(instance)
367627
def _patched_method(self, method, *args, **kwargs):
        
        self._validate()
        result = method(*args, **kwargs)
        self._validate()
        return result
825682
def patchCurses(self):
        
        if (sys.version_info)[:3] == (3, 4, 0):
            self.addchar = lambda y, x, *args: self.win.addch(x, y, *args)
        else:
            self.addchar = self.win.addch
710839
def patches
      patch = {}
      loaded_headers.each do |header|
        header.patches.each do |key, val|
          patch[key + header.offset] = val
        end
      end
      patch
    end
43387
private void registerOperations() {
    Class<?> type = getClass();
    for (Method method : type.getMethods()) {
      if (isOperationMethod(method)) {
        registerMethod(method);
      }
    }
  }
923213
def register_models(self, *models, **kwargs):
        

        for model in models:
            self.register(model, **kwargs)
937518
def register(self):
        
        form = self._get_form('SECURITY_REGISTER_FORM')
        if form.validate_on_submit():
            user = self.security_service.user_manager.create(**form.to_dict())
            self.security_service.register_user(user)
            return self.redirect('SECURITY_POST_REGISTER_REDIRECT_ENDPOINT')

        return self.render('register',
                           register_user_form=form,
                           **self.security.run_ctx_processor('register'))
638439
def commit(self):  # pylint: disable=no-self-use
        """"""
        if self._config_changed:
            self._last_working_config = self._download_running_config()
            self._config_history.append(self._last_working_config)
            self._committed = True  # comfiguration was committed
            self._config_changed = False  # no changes since last commit :)
            return True  # this will be always true
            # since the changes are automatically applied
        self._committed = False  # make sure the _committed attribute is not True by any chance
        return False