Adds a check universally.
160539
def add_check(self, check_item):
        """"""
        self.checks.append(check_item)
        for other in self.others:
            other.add_check(check_item)
665884
boolean addAndCheckIfReady(int event) {
        int b = bits.addAndGet(event);
        boolean isReady = b == READY_WITHOUT_SIGNAL || b == READY_WITH_UNNECESSARY_SIGNAL || b == READY_WITH_SIGNAL;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "addAndCheckIfReady " + event + ", polling state: " + b + ", " + isReady);
        return isReady;
    }
16426
public void setAlarmsEnabled(final boolean CHECK) {
        if (null == alarmsEnabled) {
            _alarmsEnabled = CHECK;
            fireUpdateEvent(VISIBILITY_EVENT);
        } else {
            alarmsEnabled.set(CHECK);
        }
    }
1191353
private void addSubtreeToCheckingStateTracking(DefaultMutableTreeNode node) {
        TreeNode[] path = node.getPath();   
        TreePath tp = new TreePath(path);
        CheckedNode cn = new CheckedNode(false, node.getChildCount() > 0, false);
        nodesCheckingState.put(tp, cn);
        for (int i = 0 ; i < node.getChildCount() ; i++) {              
            addSubtreeToCheckingStateTracking((DefaultMutableTreeNode) tp.pathByAddingChild(node.getChildAt(i)).getLastPathComponent());
        }
    }
158425
def check(self, options=None):
        """"""
        self.check_values(options)
        self.check_attributes(options)
        self.check_values(options)
        return self
643160
def Validate(self):
    """"""
    if not self.check_id:
      raise DefinitionError("Check has missing check_id value")
    cls_name = self.check_id
    if not self.method:
      raise DefinitionError("Check %s has no methods" % cls_name)
    ValidateMultiple(self.method,
                     "Check %s has invalid method definitions" % cls_name)
398701
def add_check(self, check):
    
    if self._add_check_callback is not None:
      if not self._add_check_callback(self, check):
        # rejected, skip!
        return False

    self._checkid2index[check.id] = len(self._checks)
    self._checks.append(check)
    return True
1167716
def run_check(self, check, argument_names):
        """"""
        arguments = []
        for name in argument_names:
            arguments.append(getattr(self, name))
        return check(*arguments)
735275
def set_check(self, name, state):
        ''''''
        if self.child.is_alive():
            self.parent_pipe.send(CheckItem(name, state))
144376
private void addClickHandlerToCheckBox(final CmsCheckBox check, final Widget unzipWidget, final CmsFileInfo file) {

        check.addClickHandler(new ClickHandler() {

            /**
             * @see com.google.gwt.event.dom.client.ClickHandler#onClick(com.google.gwt.event.dom.client.ClickEvent)
             */
            public void onClick(ClickEvent event) {

                // add or remove the file from the list of files to upload
                if (check.isChecked()) {
                    getFilesToUpload().put(file.getFileName(), file);
                    if (unzipWidget != null) {
                        enableUnzip(unzipWidget);
                    }
                } else {
                    getFilesToUpload().remove(file.getFileName());
                    if (unzipWidget != null) {
                        disableUnzip(unzipWidget);
                    }
                }

                // disable or enable the OK button
                if (getFilesToUpload().isEmpty()) {
                    disableOKButton(Messages.get().key(Messages.GUI_UPLOAD_NOTIFICATION_NO_FILES_0));
                } else {
                    enableOKButton();
                }

                // update summary
                updateSummary();

            }

            /**
             * Disables the 'unzip' button
             *
             * @param unzip the unzip button
             */
            private void disableUnzip(Widget unzip) {

                ((CmsToggleButton)unzip).setEnabled(false);
            }

            /**
             * Enables the 'unzip' button
             *
             * @param unzip the unzip button
             */
            private void enableUnzip(Widget unzip) {

                ((CmsToggleButton)unzip).setEnabled(true);
            }
        });
    }
90724
def register_check(check, codes=None):
    """"""
    def _add_check(check, kind, codes, args):
        if check in _checks[kind]:
            _checks[kind][check][0].extend(codes or [])
        else:
            _checks[kind][check] = (codes or [''], args)
    if inspect.isfunction(check):
        args = _get_parameters(check)
        if args and args[0] in ('physical_line', 'logical_line'):
            if codes is None:
                codes = ERRORCODE_REGEX.findall(check.__doc__ or '')
            _add_check(check, args[0], codes, args)
    elif inspect.isclass(check):
        if _get_parameters(check.__init__)[:2] == ['self', 'tree']:
            _add_check(check, 'tree', codes, None)
1189993
def insert_check(self, index, check_item):
        """"""
        self.checks.insert(index, check_item)
        for other in self.others:
            other.insert_check(index, check_item)
324412
def add(self, record):
        """"""
        self._field.validate_value(record)
        self._elements[record.id] = record
        self._sync_field()
1270074
def add_net(self, net):
        

        self.sanity_check_net(net)
        self.logic.add(net)
1084431
def add_global(self, **values):
        """"""
        with self._lock:
            self._ensure_global()
            self._gpayload.update(**values)
995685
def register_checkers(linter):
    """"""
    linter.register_checker(ModelChecker(linter))
    linter.register_checker(DjangoInstalledChecker(linter))
    linter.register_checker(JsonResponseChecker(linter))
    linter.register_checker(FormChecker(linter))
391584
public void addMisMatch(String name, String expected, String actual) {
        result = "NOK";
        Mismatch mismatch = new Mismatch();
        mismatch.name = name;
        mismatch.expected = expected;
        mismatch.actual = actual;
        mismatches.add(mismatch);
    }