Stores the processing state.
429987
def __store_processing_state(self):
        

        steps = self.Application_Progress_Status_processing.Processing_progressBar.maximum()
        value = self.Application_Progress_Status_processing.Processing_progressBar.value()
        message = self.Application_Progress_Status_processing.Processing_label.text()
        state = self.__is_processing

        self.__processing_state = steps, value, message, state
1090359
public ProcessRecord setProcessState(ProcessRecord processRecord,
      ProcessState newState) throws IOException {
    Put put = new Put(keyConv.toBytes(processRecord.getKey()));
    put.addColumn(Constants.INFO_FAM_BYTES,
        Constants.PROCESSING_STATE_COLUMN_BYTES,
        Bytes.toBytes(newState.getCode()));
    Table processRecordTable = null;
    try {
      processRecordTable = hbaseConnection
          .getTable(TableName.valueOf(Constants.JOB_FILE_PROCESS_TABLE));
      processRecordTable.put(put);
    } finally {
      if (processRecordTable != null) {
        processRecordTable.close();
      }
    }

    ProcessRecord updatedProcessRecord = new ProcessRecord(
        processRecord.getCluster(), newState,
        processRecord.getMinModificationTimeMillis(),
        processRecord.getMaxModificationTimeMillis(),
        processRecord.getProcessedJobFiles(), processRecord.getProcessFile(),
        processRecord.getMinJobId(), processRecord.getMaxJobId());
    return updatedProcessRecord;
  }
852192
public void process() {
    // are we ready to process yet, or have we had an error, and are
    // waiting a bit longer in the hope that it will resolve itself?
    if (error_skips > 0) {
      error_skips--;
      return;
    }
    
    try {
      if (logger != null)
        logger.debug("Starting processing");
      status = "Processing";
      lastCheck = System.currentTimeMillis();

      // FIXME: how to break off processing if we don't want to keep going?
      processor.deduplicate(batch_size);

      status = "Sleeping";
      if (logger != null)
        logger.debug("Finished processing");
    } catch (Throwable e) {
      status = "Thread blocked on error: " + e;
      if (logger != null)
        logger.error("Error in processing; waiting", e);
      error_skips = error_factor;
    }
  }
600901
def process_request(self):
        """"""
        self.response = self.request_handler.process_request(
            self.method, self.request_data)
472968
def PushState(self, **_):
    """"""
    if self.verbose:
      logging.debug("Storing state %r", self.state)
    self.state_stack.append(self.state)
457370
def save_state(self, fname=None):
        """"""
        if not fname:
            date = datetime.datetime.now().strftime("%Y-%m-%dT%Hh%Mm%Ss")
            fname = date + "_energy_" + str(self.energy()) + ".state"
        with open(fname, "wb") as fh:
            pickle.dump(self.state, fh)
332588
protected function storeData()
    {
        if ($this->currentCellIsDirty && !empty($this->currentObjectID)) {
            $this->currentObject->detach();

            fseek($this->fileHandle, 0, SEEK_END);

            $this->cellCache[$this->currentObjectID] = array(
                'ptr' => ftell($this->fileHandle),
                'sz'  => fwrite($this->fileHandle, serialize($this->currentObject))
            );
            $this->currentCellIsDirty = false;
        }
        $this->currentObjectID = $this->currentObject = null;
    }
1281675
protected function storeIteratorState()
    {
        if (! $this->startedIterating) {
            $this->current = null;
            $this->key = null;
            $this->valid = false;
            return null;
        }

        $this->current = $this->ensureIterator()->current();
        $this->key = $this->ensureIterator()->key();
        $this->valid = $this->ensureIterator()->valid();

        if ($this->current !== null) {
            $this->current = TypeConverter::toLegacy($this->current);
        }

        return $this->current;
    }
300090
public function process()
    {
        $rule = $this->getComponent();
        $context = $this->getContext();

        $processor = $this->getRuleProcessorFactory()->createProcessor($rule);
        $processor->setState($context);
        $processor->process();

        $this->trace($rule->getQtiClassName());
    }
1202760
def save_state(internal_request, state):
        
        state_data = {"hash_type": internal_request.user_id_hash_type}
        state[UserIdHasher.STATE_KEY] = state_data
663287
def store_state
      response = get
      success = !!(response.body =~ %r(state))
      data = JSON.parse(response.body) if success
      @state = data.fetch('state')
      delete_forbidden_stats
      success
    end
196097
public function process()
    {
        $this->getVisitor();
        $this->saveVisitor();

        if (!$this->visitor->hasUserId() && !Yii::$app->user->isGuest) {
            $this->visitor->setUserId(Yii::$app->user->identity->getId());
        }

        if ($this->detectFirstVisitSource) {

        }

        if ($this->detectAllVisitsSources) {

        }

        if ($this->storeLastActivity) {
            $this->visitor->save();
        }

        if ($this->storeVisitedPages) {

        }
    }
77820
def PushState(self, **unused_kwargs):
    """"""
    logging.debug('Storing state {0:s}'.format(repr(self.state)))
    self.state_stack.append(self.state)
758834
function () {
    var self = this;
    if (!self._waitingForQuiescence())
      self._flushBufferedWrites();
    _.each(self._stores, function (s) {
      s.saveOriginals();
    });
  }
270700
public void setProcessing(final boolean processing) {
        final boolean old = this.processing;
        this.processing = processing;

        this.pcs.firePropertyChange("processing", old, this.processing);
    }
740633
def _process_response(self, response):
        
        assert self._state == self._STATE_RUNNING, "Should be running if processing response"
        cols = None
        data = []
        for r in response:
            if not cols:
                cols = [(f, r._fields[f].db_type) for f in r._fields]
            data.append([getattr(r, f) for f in r._fields])
        self._data = data
        self._columns = cols
        self._state = self._STATE_FINISHED
211148
def _process_incoming_data(self):
        
        while self._running.is_set():
            if self.poller.is_ready:
                self.data_in += self._receive()
                self.data_in = self._on_read_impl(self.data_in)