before that needs to be updated.
348767
private RuleModel updateMethodCall(RuleModel model) {

        for (int i = 0; i < model.rhs.length; i++) {
            if (model.rhs[i] instanceof ActionCallMethod) {
                ActionCallMethod action = (ActionCallMethod) model.rhs[i];
                // Check if method name is filled, if not this was made with an older Guvnor version
                if (action.getMethodName() == null || "".equals(action.getMethodName())) {
                    if (action.getFieldValues() != null && action.getFieldValues().length >= 1) {
                        action.setMethodName(action.getFieldValues()[0].getField());

                        action.setFieldValues(new ActionFieldValue[0]);
                        action.setState(ActionCallMethod.TYPE_DEFINED);
                    }
                }
            }
        }

        return model;
    }
1049882
private void updateLastForce()
    {
        if (Double.compare(fhLast, fhDest) != 0)
        {
            fhLast = fhDest;
            arrivedH = false;
        }
        if (Double.compare(fvLast, fvDest) != 0)
        {
            fvLast = fvDest;
            arrivedV = false;
        }
    }
521053
public function updateProgress()
    {
        foreach ($this->employees as $employee) {
            if ($employee->isBusy()) {
                continue;
            }

            if ($employee->isFree()) {
                continue;
            }

            $job = $employee->getJob();

            switch ($employee->getWorkState()) {
                case Employee::COMPLETE:
                    if (method_exists($job, 'beforeComplete')) {
                        $job->beforeComplete();
                    }
                    $this->pipeline->complete($job);
                    break;
                case Employee::FAILED:
                    if (method_exists($job, 'beforeFail')) {
                        $job->beforeFail();
                    }
                    if ($job->mayTryAgain()) {
                        $this->pipeline->reset($job);
                    } else {
                        $this->pipeline->fail($job);
                    }
                    break;
            }

            $employee->free();
        }
    }
758461
public void update(Date lastScheduledExecutionTime, Date lastActualExecutionTime, Date lastCompletionTime) {
        this.lastScheduledExecutionTime = lastScheduledExecutionTime;
        this.lastActualExecutionTime = lastActualExecutionTime;
        this.lastCompletionTime = lastCompletionTime;
    }
514852
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi1*con.tind)
121078
protected void updated()
    {
        if (remaining < 0 && remaining > capacity)
        {
            throw new IllegalArgumentException(remaining+" illegal remaining at %s"+toString());
        }
        if (marked < 0 && marked > capacity)
        {
            throw new IllegalArgumentException(marked+" illegal marked at %s"+toString());
        }
    }
16623
void update() {
        Application.update(filter, list, main, footer, toggleAll, count, clearCompleted);
    }
1007089
def before_processing(eng, objects):
        """"""
        super(InvenioProcessingFactory, InvenioProcessingFactory)\
            .before_processing(eng, objects)
        eng.save(WorkflowStatus.RUNNING)
        db.session.commit()
457857
function() {
		edbml.Update.prototype.update.call(this);
		var element = this.element();
		if (element && this._beforeUpdate(element)) {
			//gui.DOMPlugin.html ( element, this.xelement.outerHTML );
			gui.DOMPlugin.html(element, this.xelement.innerHTML);
			this._afterUpdate(element);
			this._report();
		}
	}
829485
def up_to_date(self):
        
#        return False
        if not self.updated:
            return False
        return (utils.get_datetime_now() - self.updated).seconds < conf.GOSCALE_POSTS_UPDATE_FREQUENCY
196966
private void updateReadyness()
	{
		StringBuffer _buffer = new StringBuffer();
		if (null == myMessageProvider)
		{
			_buffer.append(NO_MESSAGE_PROVIDER);
		}
		if (null == myIconProvider)
		{
			if (_buffer.length() > 0)
			{
				_buffer.append(COMMA);
			}
			_buffer.append(NO_ICON_PROVIDER);
		}
		if (_buffer.length() > 0)
		{
			_buffer.append(DOT);
		}
		myReasonWhyNotReady = _buffer.toString();
		myIsReady = (_buffer.length() == 0);

	}
907666
public boolean beforeUpdate(List<Object> tList, String setSql, List<Object> setSqlArgs) {
    	return true;
    }
280988
private void updateDecoration() {
        if (lastResult != null) {
            if (lastResult) {
                setIcon(validIcon);
                setToolTipText(validText);
            } else {
                setIcon(invalidIcon);
                setToolTipText(invalidText);
            }
        }
    }
1263571
private void update() {
        if (!predefinedPriori) {
            for (int c = 0; c < k; c++) {
                priori[c] = (nc[c] + EPSILON) / (n + k * EPSILON);
            }
        }

        if (model == Model.MULTINOMIAL || model == Model.POLYAURN) {
            for (int c = 0; c < k; c++) {
                for (int t = 0; t < p; t++) {
                    condprob[c][t] = (ntc[c][t] + sigma) / (nt[c] + sigma * p);
                }
            }
        } else {
            for (int c = 0; c < k; c++) {
                for (int t = 0; t < p; t++) {
                    condprob[c][t] = (ntc[c][t] + sigma) / (nc[c] + sigma * 2);
                }
            }
        }
    }
761574
def update(self, data):
        """"""
        if data is None:
            for device in self.devices:
                device.clear_info()
        else:
            for device, device_info in zip(self.devices, data):
                device.device_info = device_info
                self.connection.log("Device information updated -> [{}]".format(device))
1145648
def _needs_update(self):
        ''

        if self.poll_interval:
            delta = timeit.default_timer() - self._last_update_timer
            poll_status = delta > self.poll_interval.total_seconds()
        else:
            delta = 0
            poll_status = False

        # Do not update if value increment is not large enough to
        # add more bars to progressbar (according to current
        # terminal width)
        try:
            divisor = self.max_value / self.term_width  # float division
            if self.value // divisor == self.previous_value // divisor:
                return poll_status or self.end_time
            else:
                return True
        except Exception:
            # ignore any division errors
            pass

        return poll_status or self.end_time
278329
def mark_for_update(self):
        '''
            
        '''
        self.pub_statuses.exclude(status=UNPUBLISHED).update(status=NEEDS_UPDATE)
        push_key.delay(self)