Reset all records that somehow got stuck in a processing state.
503830
public synchronized void resetProcessingShareRequests() {
        SQLiteDatabase db = null;
        try {
            db = getWritableDatabase();

            // Update state back to pending.
            ContentValues values = new ContentValues();
            values.put(ShareRequestTable.COLUMN_STATE, ShareRequest.STATE_PENDING);

            int recordsUpdated = db.update(ShareRequestTable.NAME, values, WHERE_CLAUSE_BY_STATE,
                    new String[]{String.valueOf(ShareRequest.STATE_PROCESSING)});

            sLogger.log(WingsDbHelper.class, "resetProcessingShareRequests", "recordsUpdated=" + recordsUpdated);
        } catch (SQLException e) {
            // Do nothing.
        } finally {
            db.close();
        }
    }
504752
def reset_everything(self, payload):
        """"""
        kill_signal = signals['9']
        self.process_handler.kill_all(kill_signal, True)
        self.process_handler.wait_for_finish()
        self.reset = True

        answer = {'message': 'Resetting current queue', 'status': 'success'}
        return answer
705865
def copy_reset(self):
        """"""
        # Reset settings
        self._filters = []
        self._filter_or = False
        self._paginate = True
        self._paginate_count = 0
        self._result_count = None
        self._result_limit = 500
        self._result_start = 0
1198704
public void reset() {
        Lock lock = this.lock.writeLock();
        lock.lock();
        try {
            doReset();
        } finally {
            lock.unlock();
        }
    }
1191445
def reset(self):
        '''
        '''
        for index in range(self.counts_len):
            self.counts[index] = 0
        self.total_count = 0
        self.min_value = sys.maxsize
        self.max_value = 0
        self.start_time_stamp_msec = sys.maxsize
        self.end_time_stamp_msec = 0
129428
public function reset()
    {
        $this->pos(0);
        $this->matchHistory = array(null, null);
        $this->ss = new StringSearch($this->src);
    }
205569
def clear(self):
        """"""
        self._wlock.acquire()
        try:
            self._mapping.clear()
            self._queue.clear()
        finally:
            self._wlock.release()
1230482
def Reset(self):
    """"""
    # The first state
    self.state = "INITIAL"
    self.state_stack = []

    # The buffer we are parsing now
    self.buffer = ""
    self.error = 0
    self.verbose = 0

    # The index into the buffer where we are currently pointing
    self.processed = 0
    self.processed_buffer = ""
1090550
public void reset() {

		// reset all offsets
		this.numRecords = 0;
		this.currentSortIndexOffset = 0;
		this.currentDataBufferOffset = 0;
		this.sortIndexBytes = 0;

		// return all memory
		returnToSegmentPool();

		// grab first buffers
		this.currentSortIndexSegment = nextMemorySegment();
		this.sortIndex.add(this.currentSortIndexSegment);
		this.recordCollector.reset();
	}
1250128
def reset(self):
        """"""
        self.curr_idx = 0
        #shuffle data in each bucket
        random.shuffle(self.idx)
        for i, buck in enumerate(self.sentences):
            self.indices[i], self.sentences[i], self.characters[i], self.label[i] = shuffle(self.indices[i],
                                                                                            self.sentences[i],
                                                                                            self.characters[i],
                                                                                            self.label[i])

        self.ndindex = []
        self.ndsent = []
        self.ndchar = []
        self.ndlabel = []

        #for each bucket of data
        for i, buck in enumerate(self.sentences):
            #append the lists with an array
            self.ndindex.append(ndarray.array(self.indices[i], dtype=self.dtype))
            self.ndsent.append(ndarray.array(self.sentences[i], dtype=self.dtype))
            self.ndchar.append(ndarray.array(self.characters[i], dtype=self.dtype))
            self.ndlabel.append(ndarray.array(self.label[i], dtype=self.dtype))
193102
public function reset() {
        $this->processstarted = false;
        $this->linenb = 0;
        $this->cir->init();
        $this->errors = array();
    }
1326505
def flush_records(self):
        
        s = b"".join(p.raw_stateful() for p in self.buffer_out)
        self.socket.send(s)
        self.buffer_out = []
550032
protected synchronized void reset() {
		if (max == 0) {
			return;
		}
		for (int i = 0; i < timestamps.length; i++) {
			timestamps[i] = 0;
		}
		min = 0;
		max = 0;
		tested = 0;
		locked = false;
	}
541501
public function reset()
	{
		$this->started = $this->now();
		$this->prefix  = '';
		$this->marks   = array();
		$this->memory  = memory_get_usage(true);
	}
935058
def _reset(self):
        """"""
        self.records = list()
        self.featsbyid = dict()
        self.featsbyparent = dict()
        self.countsbytype = dict()
86252
def reset(self):
        """"""
        self.curr_idx = 0
        random.shuffle(self.idx)
        for buck in self.data:
            np.random.shuffle(buck)
1347950
def _reset_state(self):
        """"""
        self._uuid = None
        self._columns = None
        self._rownumber = 0
        # Internal helper state
        self._state = self._STATE_NONE
        self._data = None
        self._columns = None