Records a miss when the hot and cold set are full.
963974
private void onFullMiss(Node node) {
    // Upon accessing an HIR non-resident block X. This is a miss. We remove the HIR resident block
    // at the bottom of stack Q (it then becomes a non-resident block) and evict it from the cache.
    // Then, we load the requested block X into the freed buffer and place it at the top of stack
    // S. There are two cases for the original location of block X: a) If X is in the stack S, we
    // change its status to LIR and move the LIR block at the bottom of stack S to the top of
    // stack Q with its status changed to HIR. A stack pruning is then conducted. This case is
    // illustrated in the transition from state(a) to state(d) in Fig.2. b) If X is not in stack S,
    // we leave its status unchanged and place it at the top of stack Q. This case is illustrated in
    // the transition from state (a) to state (e) in Fig. 2.

    node.status = Status.HIR_RESIDENT;
    if (residentSize >= maximumSize) {
      evict();
    }

    boolean isInStack = node.isInStack(StackType.S);
    node.moveToTop(StackType.S);

    if (isInStack) {
      node.status = Status.LIR;
      sizeHot++;

      Node bottom = headS.prevS;
      checkState(bottom.status == Status.LIR);

      bottom.status = Status.HIR_RESIDENT;
      bottom.removeFrom(StackType.S);
      bottom.moveToTop(StackType.Q);
      sizeHot--;

      pruneStack();
    } else {
      node.moveToTop(StackType.Q);
    }
  }
456296
function finished(err) {
    if (err) self.critical('Failed to store %s. %s.', base, err.message);
    if (fn) fn(err, collection);
  }
587795
public void record(long timeNano, int numEvents) {
    long leftEndPoint = bucket(timeNano);
    mSeries.put(leftEndPoint, mSeries.getOrDefault(leftEndPoint, 0) + numEvents);
  }
406077
function seterror(error_name,desc,has_required){
			err =	{error:error_name,
				description:desc,
				method:'GET',
				action:'rpdquery',
				notes:'run a SQL statement stored serverside by name and other required parameters'}
			if (has_required == 1){				
				err.required = ['csql', 'limit', 'offset'];
				err.csql   = 'sql statement name';
				err.limit  = 'number of records to be returned';
				err.offset = 'start record number from result set'};
				return err
			}
170913
public static void notEmpty(Collection collection, String name) {
    notNull(collection, name);

    if (collection.isEmpty()) {
      throw new IllegalArgumentException(name + " must not be empty");
    }
  }
200640
public void record(String line, DispatchCallback callback) {
    if (sqlLine.getRecordOutputFile() == null) {
      startRecording(line, callback);
    } else {
      stopRecording(line, callback);
    }
  }
1201309
def _raise_error_if_container_is_missing_an_utterance(self):
        
        expected_keys = frozenset(self.utt_ids)

        for cnt in self.containers:
            keys = set(cnt.keys())

            if not keys.issuperset(expected_keys):
                raise ValueError('Container is missing data for some utterances!')
166038
public void check(Map<String,Object> record) throws BadDataException {
        if(Objects.isNullOrEmpty(record.get("id")))
            throw new BadDataException("id");
    }
562505
def record(amount)
      return if amount < 0
      @count.add_and_get(1)
      @total_amount.add_and_get(amount)
      @total_sq.add_and_get(amount * amount)
      @max.max(amount)
    end
1089952
public void record(double amount) {
    if (amount >= 0.0) {
      add(totalAmount, amount);
      add(totalOfSquares, amount * amount);
      max(max, amount);
      count.incrementAndGet();
      lastUpdateTime.set(clock.wallTime());
    }
  }
852033
def errorRecorder(self, lineNumber, offset, text, check):
        
        code = text.split(" ")[0]
        lineOffset = self.report.line_offset

        self.warnings.append((lineOffset + lineNumber,
                              offset + 1, code, text))
48709
function(record) {
        var i;
        if(record instanceof widget.Record) {
            for(i=0; i<this._records.length; i++) {
                if(this._records[i] && (this._records[i]._sId === record._sId)) {
                    return record;
                }
            }
        }
        else if(lang.isNumber(record)) {
            if((record > -1) && (record < this.getLength())) {
                return this._records[record];
            }
        }
        else if(lang.isString(record)) {
            for(i=0; i<this._records.length; i++) {
                if(this._records[i] && (this._records[i]._sId === record)) {
                    return this._records[i];
                }
            }
        }
        // Not a valid Record for this RecordSet
        return null;

    }
333103
private void afterRecord() {
        if (fileNamePattern != null && getRecordCounter() % splitlimit == 0) {
            try {
                endCollection();
                close();
                newWriter(fileNamePattern, fileNameCounter, bufferSize, compress);
                top = true;
                beginCollection();
            } catch (IOException e) {
                logger.log(Level.SEVERE, e.getMessage(), e);
            }
        }
    }
848603
def _get_recording(self, index):
        """"""
        assert index >= 0
        recs = np.nonzero((index - self.offsets[:-1]) >= 0)[0]
        if len(recs) == 0:  # pragma: no cover
            # If the index is greater than the total size,
            # return the last recording.
            return len(self.arrs) - 1
        # Return the last recording such that the index is greater than
        # its offset.
        return recs[-1]
661680
def record(self, i=0):
        """"""
        f = self.__getFileObj(self.dbf)
        if not self.numRecords:
            self.__dbfHeader()
        i = self.__restrictIndex(i)
        recSize = self.__recordFmt()[1]
        f.seek(0)
        f.seek(self.__dbfHeaderLength() + (i * recSize))
        return self.__record()
30786
private void recordCounterAndTimer(MixinMetric mixinMetric, RpcAbstractLookoutModel model) {
        Counter totalCounter = mixinMetric.counter("total_count");
        Timer totalTimer = mixinMetric.timer("total_time");

        Long elapsedTime = model.getElapsedTime();

        totalCounter.inc();
        if (elapsedTime != null) {
            totalTimer.record(elapsedTime, TimeUnit.MILLISECONDS);
        }

        if (!model.getSuccess()) {
            Counter failCounter = mixinMetric.counter("fail_count");
            Timer failTimer = mixinMetric.timer("fail_time");

            failCounter.inc();
            if (elapsedTime != null) {
                failTimer.record(elapsedTime, TimeUnit.MILLISECONDS);
            }
        }
    }
837051
def filter_record(self, record):
        

        if len(record) >= self.min_length:
            return record
        else:
            raise FailedFilter(len(record))