Sets current status of a check

        :param value: ``True`` (healthy), ``False`` (unhealthy), or ``None``
            (unknown)
195202
def set(self, value: Optional[bool]):
        
        prev_value = self._value
        self._value = value
        if self._value != prev_value:
            # notify all watchers that this check was changed
            for event in self._events:
                event.set()
784380
def run_checked (self):
        """"""
        self.start_time = time.time()
        self.setName("Status")
        # the first status should be after a second
        wait_seconds = 1
        first_wait = True
        while not self.stopped(wait_seconds):
            self.log_status()
            if first_wait:
                wait_seconds = self.wait_seconds
                first_wait = False
1307739
def set_current_value(self, value):
        """"""
        self._oldvalue = self.get_current_value()
        self._currentvalue = value
        if self._oldvalue != value:
            # self.notify_observers("new_ip_detected", {"ip": value})
            LOG.debug("%s.set_current_value(%s)", self.__class__.__name__, value)
        return value
439523
@Override
    public void setStatus(int value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "setStatus(int) : " + value);
        }

        // check if the buffer should be converted before setting the status
        if (value == STATUS_BUFFER) {
            convertBufferIfNeeded();
        }
        this.status = value;
    }
223065
def set_value(self, value, block_events=False):
        
        if block_events: self.block_events()
        self._widget.setValue(value)
        if block_events: self.unblock_events()
1023913
public function checkHealth()
    {
        if (!$this->process->isRunning()) {
            if ($this->status == self::STATUS_CLEANINGUP || $this->status == self::STATUS_CLEANEDUP) {
                //okay so we're ready to stop!
                $this->status = self::STATUS_DEAD;
                return true;
            } elseif ($this->status == ChildProcessContainer::STATUS_SLEEPY) {
                //okay so we're ready to stop!
                $this->status = self::STATUS_DEAD;
                return true;
            }
            $this->status = self::STATUS_DEAD;
            return false;
        } else {
            return true;
        }

    }
638407
synchronized void setHealthStatus(TaskTrackerHealthStatus healthStatus) {
    healthStatus.setNodeHealthy(this.isHealthy());
    healthStatus.setHealthReport(this.getHealthReport());
    healthStatus.setLastReported(this.getLastReportedTime());
  }
742965
def set_checklists_status(auth, args):
    """"""
    global checklists_on

    if auth['checklists'] == "true":
        checklists_on = True
    else:
        checklists_on = False

    # reverse the config setting if specified by the CLI option
    if args['--checklists']:
        checklists_on = not checklists_on

    return
923799
def status(self, status):
        
        allowed_values = ["pending", "awaitingRetry", "successful", "failed"]
        if status is not None and status not in allowed_values:
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"
                .format(status, allowed_values)
            )

        self._status = status
216773
def setChecked(self, state):
        
        super(XLockButton, self).setChecked(state)
        self.updateState()
374324
async def health_check(self) -> Iterator[HealthCheckFail]:
        

        ds_class = getattr(settings, 'DEFAULT_STATE', '')
        forbidden_defaults = [None, '', 'bernard.engine.state.DefaultState']

        if ds_class in forbidden_defaults:
            yield HealthCheckFail(
                '00005',
                f'Default state (`DEFAULT_STATE` in settings) is not set. '
                f'You need to set it to your own implementation. Please refer '
                f'yourself to the doc. See '
                f'https://github.com/BernardFW/bernard/blob/develop/doc/'
                f'get_started.md#statespy'
            )

        try:
            import_class(ds_class)
        except (ImportError, KeyError, AttributeError, TypeError):
            yield HealthCheckFail(
                '00005',
                f'Cannot import "{ds_class}", which is the value'
                f' of `DEFAULT_STATE` in the configuration. This means either'
                f' that your `PYTHONPATH` is wrong or that the value you gave'
                f' to `DEFAULT_STATE` is wrong. You need to provide a default'
                f' state class for this framework to work. Please refer'
                f' yourself to the documentation for more information. See'
                f' https://github.com/BernardFW/bernard/blob/develop/doc/'
                f'get_started.md#statespy'
            )

        states = set(t.dest for t in self.transitions)

        for state in states:
            async for check in state.health_check():
                yield check
334165
private void updateCheckboxState(CmsPublishItemStateSummary value) {

        CheckBoxUpdate update = updateCheckbox(value);
        m_selectAll.setText(update.getText());
        m_selectAll.setTitle(update.getAction());
        m_selectAll.setState(update.getState(), false);

    }
930207
public function setStatus($value)
    {
        $this->_validateNotNull('Status', $value);
        $this->_validateInt('Status', $value);

        if ($this->data['status'] === $value) {
            return;
        }

        $this->data['status'] = $value;

        $this->_setModified('status');
    }
465389
def check_positive(value, strict=False):
    
    if not strict and value < 0:
        raise ValueError("Value must be positive or zero, not %s" % str(value))
    if strict and value <= 0:
        raise ValueError("Value must be positive, not %s" % str(value))
1258028
def setCurrentValue(self, value):
        
        enum = self.enum()
        if not enum:
            return
        
        if self.isCheckable():
            indexes = []
            for i in range(self.count()):
                try:
                    check_value = enum[nativestring(self.itemText(i))]
                except KeyError:
                    continue
                
                if check_value & value:
                    indexes.append(i)
            self.setCheckedIndexes(indexes)
        else:
            try:
                text = enum[value]
            except (AttributeError, KeyError):
                return
            
            self.setCurrentIndex(self.findText(text))
815626
def __set_status(self, value):
        '''
        
        '''
        if value not in [DELIVERY_METHOD_STATUS_PENDING,
                         DELIVERY_METHOD_STATUS_SENT,
                         DELIVERY_METHOD_STATUS_CONFIRMED,
                         DELIVERY_METHOD_STATUS_BOUNCED]:
            raise ValueError("Invalid deliveries method status '%s'" % value)

        self.__status = value
464708
def state(self, value):
        
        self._state = value
        self.state_changed.emit(value)