Updates the measure overview. If no measures are currently to display,
reset the display to hyphens. Otherwise display the last measured and
mean values.
966825
public void update() {
        if (this.measures == null || this.measures.length == 0) {
            // no measures to show -> empty entries
            for (int i = 0; i < this.currentValues.length; i++) {
                this.currentValues[i].setText("-");
                this.meanValues[i].setText("-");
            }
            return;
        }
        
        DecimalFormat d = new DecimalFormat("0.00");
        
        MeasureCollection mc;
        if (this.measures.length > this.measureCollectionSelected) {
        	mc = this.measures[this.measureCollectionSelected];
        }
        else {
        	mc = this.measures[0];
        }
        
        for (int i = 0; i < this.currentValues.length; i++) {
            // set current value
            if(Double.isNaN(mc.getLastValue(i))) {
                this.currentValues[i].setText("-");
            } else {
                this.currentValues[i].setText(d.format(mc.getLastValue(i)));
            }
            
            // set mean value
            if(Double.isNaN(mc.getMean(i))) {
                this.meanValues[i].setText("-");
            } else {
                this.meanValues[i].setText(d.format(mc.getMean(i)));
            }
        } 
    }
866415
@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mOrientation == HORIZONTAL) {
            setMeasuredDimension(measureLong(widthMeasureSpec), measureShort(heightMeasureSpec));
        } else {
            setMeasuredDimension(measureShort(widthMeasureSpec), measureLong(heightMeasureSpec));
        }
    }
1050942
def update(self):
        """"""
        for linenum in reversed(sorted(self.updates)):
            self.replace_baseline_repr(linenum, self.updates[linenum])

        if not self.TEST_MODE:
            path = '{}.update{}'.format(*os.path.splitext(self.path))
            with io.open(path, 'w', encoding='utf-8') as fh:
                fh.write('\n'.join(self.lines))
            print('UPDATE: {}'.format(self.showpath(path)))
79346
def update(self, duration):
        """"""
        if duration >= 0:
            self.histogram.update(duration)
            self.meter.mark()
1131036
protected void updatePageStatus() {
		final boolean ok;
		if (Strings.isEmpty(this.titleField.getText())) {
			ok = false;
			setMessage(Messages.IssueInformationPage_5, IMessageProvider.ERROR);
		} else if (Strings.isEmpty(this.trackerLogin.getText())) {
			ok = false;
			setMessage(Messages.IssueInformationPage_6, IMessageProvider.ERROR);
		} else if (Strings.isEmpty(this.trackerPassword.getText())) {
			ok = false;
			setMessage(Messages.IssueInformationPage_7, IMessageProvider.ERROR);
		} else {
			ok = true;
			if (Strings.isEmpty(this.descriptionField.getText())) {
				setMessage(Messages.IssueInformationPage_8, IMessageProvider.WARNING);
			} else {
				setMessage(null, IMessageProvider.NONE);
			}
		}
		setPageComplete(ok);
	}
1084767
void updateJournalMetrics() {
    if (metrics == null) {
      return;
    }
    int failedJournals = 0;
    for(JournalAndStream jas : journals) {
      if(jas.isDisabled()) {
        failedJournals++;
      }
    }
    metrics.journalsFailed.set(failedJournals);
  }
302078
def gauge(self, stats, value):
        
        self.update_stats(stats, value, self.SC_GAUGE)
1372798
public void notifyStatusChanged(String status) {

    /* If the new status message is shorter than the previous one, then
     * first change the status message all spaces to clear out the previous
     * message.
     */
    if (status.length() < this.status.length()) {
      this.status = this.status.replaceAll(".", " ");
      this.printProgressBar();
    }

    this.status = status;
    this.printProgressBar();

  }
411330
private void updateStatistics() {
        final PNCounterService service = getService();
        final LocalPNCounterStatsImpl stats = service.getLocalPNCounterStats(name);
        if (delta > 0) {
            stats.incrementIncrementOperationCount();
        } else if (delta < 0) {
            stats.incrementDecrementOperationCount();
        }
        stats.setValue(getBeforeUpdate ? (response.getValue() + delta) : response.getValue());
    }
130735
def update_metric(self, eval_metric, labels, pre_sliced=False):
        
        assert self.binded and self.params_initialized

        for meta, module in zip(self._metas, self._modules):
            if SequentialModule.META_TAKE_LABELS in meta and \
                    meta[SequentialModule.META_TAKE_LABELS]:
                module.update_metric(eval_metric, labels, pre_sliced)
160078
def update_displayed_information(self):
        

        for source in self.controller.sources:
            source_name = source.get_source_name()
            if (any(self.graphs_menu.active_sensors[source_name]) or
                    any(self.summary_menu.active_sensors[source_name])):
                source.update()

        for graph in self.visible_graphs.values():
            graph.update()

        # update graph summery
        for summary in self.visible_summaries.values():
            summary.update()

        # Only update clock if not is stress mode
        if self.controller.stress_conroller.get_current_mode() != 'Monitor':
            self.clock_view.set_text(seconds_to_text(
                (timeit.default_timer() - self.controller.stress_start_time)))
619874
def _update_status(self):
        '''  '''
        label = ''
        # label format, based on time - when slow, go to higher-res display
        delta = time.time() - self.start
        if delta > self.timedelta2:
            self.label_fmt = '%5.2f%%'
        elif delta > self.timedelta1:
            self.label_fmt = '%4.1f%%'

        ratio = self.ratio
        if 0 <= ratio < 1:
            if self.label_mode:
                label = self.label_fmt % (ratio * 100)
            if self.oob_error:  # now fixed, reset
                self._first = self.styles[_if](self.icons[_if])
                self._last = self.styles[_il](self.icons[_il])
                self.oob_error = False
                self._comp_style = self.styles[_ic]
                self.done = False
        else:
            if ratio == 1:
                self.done = True
                self._comp_style = self.styles[_id]
                self._last = self.styles[_if](self.icons[_il])
                if self.label_mode:
                    label = '✓' if self.unicode_support else '+'
                if self.oob_error:  # now fixed, reset
                    self._first = self.styles[_if](self.icons[_if])
                    self.oob_error = False

            elif ratio > 1:
                self.done = True
                self.oob_error = True
                if self.unicode_support:
                    self._last = self._err_style('⏵')
                    if self.label_mode:
                        label = '✗'
                else:
                    self._last = self._err_style('>')
                    if self.label_mode:
                        label = 'ERR'
            else:  # < 0
                self.oob_error = True
                if self.unicode_support:
                    self._first = self._err_style('⏴')
                    if self.label_mode:
                        label = '✗'
                else:
                    self._first = self._err_style('<')
                    if self.label_mode:
                        label = 'ERR'
        self._lbl = label
1107965
private void updateScaleList() {
		refreshPixelLength(); /* retrieve pixelLength from mapWidget. Needed in case mapWidget wasn't fully initialized
					the previous time the pixelLength was requested */

		// Update lookup map (stores user friendly representation):
		valueToScale.clear();
		if (!Double.isNaN(pixelLength) && (0.0 != pixelLength)) {
			for (Double scale : scaleList) {
				// Eliminate duplicates and null:
				if (scale != null) {
					String value = ScaleConverter.scaleToString(scale, precision, significantDigits);
					valueToScale.put(value, scale);
				}
			}

			List<String> availableScales = new ArrayList<String>();

			for (Double scale : scaleList) {
				if (mapView.isResolutionAvailable(pixelLength / scale)) {
					availableScales.add(ScaleConverter.scaleToString(scale, precision, significantDigits));
				}
			}

			scaleItem.setValueMap(availableScales.toArray(new String[availableScales.size()]));

			isScaleItemInitialized = true;
		}
	}
154754
public void recalculateMeta() {
        data.yDataType = null;
        data.xDataTypes.clear();
        for(Record r : values()) {
            updateMeta(r);
        }
    }
1228560
private void updateChart() {
        Platform.runLater(() -> {
            List<LeaderBoardItem> items = tile.getLeaderBoardItems();
            int noOfItems = items.size();
            if (noOfItems == 0) return;
            double maxY = height - size * 0.25;
            for (int i = 0 ; i < noOfItems ; i++) {
                LeaderBoardItem item = items.get(i);
                double y = i * 0.175 * size; //size * 0.18 + i * 0.175 * size;
                if (y < maxY) {
                    item.setManaged(true);
                    item.setVisible(true);
                    item.relocate(0, y);
                } else {
                    item.setVisible(false);
                    item.setManaged(false);
                }
            }
        });
    }
721988
def update(self, **params):
        
        self._current_params = self._transform_params(**params)
        self._current_stats = ModelStats()
1012466
private function updateDiffTimestamp()
    {
        $diffTimestamp = 0;
        $lastTimeStamp = 0;
        $lastActivity = 0;
        if (isset($this->data[DeliveryMonitoringService::LAST_PAUSE_TIMESTAMP])) {
            $lastTimeStamp = $this->data[DeliveryMonitoringService::LAST_PAUSE_TIMESTAMP];
        }

        if (isset($this->data[DeliveryMonitoringService::LAST_TEST_TAKER_ACTIVITY])) {
            $lastActivity = $this->data[DeliveryMonitoringService::LAST_TEST_TAKER_ACTIVITY];
        }

        if ($lastTimeStamp - $lastActivity > 0) {
            $diffTimestamp = isset($this->data[DeliveryMonitoringService::DIFF_TIMESTAMP]) ? $this->data[DeliveryMonitoringService::DIFF_TIMESTAMP] : 0;
            $diffTimestamp += $lastTimeStamp - $lastActivity;
        }

        $this->addValue(DeliveryMonitoringService::DIFF_TIMESTAMP, $diffTimestamp, true);
    }