Remove all measurements from self.measurements. Reset the
        measurement counter. All ID are invalidated.
320968
def clear_measurements(self):
        
        keys = list(self.measurements.keys())
        for key in keys:
            del(self.measurements[key])
        self.meas_counter = -1
816809
def reset(self):
        
        if getattr(self, 'num', None) is None:
            self.num_inst = 0
            self.sum_metric = 0.0
        else:
            self.num_inst = [0] * self.num
            self.sum_metric = [0.0] * self.num
711725
function() {
    this._latlngs = [];
    this._resultsModel = null;
    this._measureVertexes.clearLayers();
    if (this._measureDrag) {
      this._layer.removeLayer(this._measureDrag);
    }
    if (this._measureArea) {
      this._layer.removeLayer(this._measureArea);
    }
    if (this._measureBoundary) {
      this._layer.removeLayer(this._measureBoundary);
    }
    this._measureDrag = null;
    this._measureArea = null;
    this._measureBoundary = null;
  }
1050830
def reset(self):
        """"""
        self.Base.metadata.drop_all(self.session.bind)
        self.initialize()
1211340
def reset(self):
        
        self.metadata.drop_all(self.engine)
        self.metadata.create_all(self.engine)
1330573
public void reset()
    {
        this.bufferSize = 0;
        this.bufferPos = 0;
        this.bufferSizeAfterLimit = 0;
        this.currentLimit = Integer.MAX_VALUE;
        this.lastTag = 0;
        this.packedLimit = 0;
        this.sizeLimit = DEFAULT_SIZE_LIMIT;
        resetSizeCounter();
    }
213718
def unregister(self, measurement_class, callback):
        
        self.callbacks[Measurement.name_from_class(measurement_class)
                ].remove(callback)
1106073
public void reset() {
        for (int i = 0; i < dimension; i++) {
            lowerBound[i] = originalLowerBound[i];
            upperBound[i] = originalUpperBound[i];
            setPrecisionUnit(i);
        }

        // setup rounded base.
        for (int i = 0; i < dimension; i++) {
            if (extendBound[i]) {
                extendBound(i);
            }
        }

        initBaseCoord();
    }
594216
def reset(self):
        """"""
        self.start = 1
        self.count = None
        self.end = None
        self.stride = 1
        self.format = "%d"
459912
def set_measurements(
        self, measurement='Weight', value=None
    ):
        
        if value is None:
            raise ValueError(
                "Cannot update blank value."
            )

        # get the URL for the main check in page
        # this is left in because we need to parse
        # the 'measurement' name to set the value.
        document = self._get_document_for_url(
            self._get_url_for_measurements()
        )

        # gather the IDs for all measurement types
        measurement_ids = self._get_measurement_ids(document)

        # check if the measurement exists before going too far
        if measurement not in measurement_ids.keys():
            raise ValueError(
                "Measurement '%s' does not exist." % measurement
            )

        # build the update url.
        update_url = parse.urljoin(
                    self.BASE_URL,
                    'measurements/save'
        )

        # setup a dict for the post
        data = {}

        # here's where we need that required element
        data['authenticity_token'] = self._authenticity_token

        # Weight has it's own key value pair
        if measurement == 'Weight':
            data['weight[display_value]'] = value

        # the other measurements have generic names with
        # an incrementing numeric index.
        measurement_index = 0

        # iterate all the measurement_ids
        for measurement_id in measurement_ids.keys():
            # create the measurement_type[n]
            # key value pair
            n = str(measurement_index)
            meas_type = 'measurement_type[' + n + ']'
            meas_val = 'measurement_value[' + n + ']'

            data[meas_type] = measurement_ids[measurement_id]

            # and if it corresponds to the value we want to update
            if measurement == measurement_id:
                # create the measurement_value[n]
                # key value pair and assign it the value.
                data[meas_val] = value
            else:
                # otherwise, create the key value pair and leave it blank
                data[meas_val] = ""

            measurement_index += 1

        # now post it.
        result = self.session.post(
            update_url,
            data=data
        )

        # throw an error if it failed.
        if not result.ok:
            raise RuntimeError(
                "Unable to update measurement in MyFitnessPal: "
                "status code: {status}".format(
                    status=result.status_code
                )
            )
724342
public static void resetAllCounters() {
    for (Map.Entry<String, Counter> entry : METRIC_REGISTRY.getCounters().entrySet()) {
      entry.getValue().dec(entry.getValue().getCount());
    }
  }
693911
def reset(self):
        
        self.dataset_index.reset()
        self.partition_index.reset()
        self.identifier_index.reset()
1219410
def stop(self, measurementId, failureReason=None):
        
        if failureReason is None:
            self.endResponseCode = self._doPut(self.sendURL + "/complete")
        else:
            self.endResponseCode = self._doPut(self.sendURL + "/failed", data={'failureReason': failureReason})
        self.sendURL = None
955954
def reset(self):
        """"""
        if getattr(self, 'num', None) is None:
            self.num_inst = 0
            self.sum_metric = 0.0
        else:
            self.num_inst = [0] * self.num
            self.sum_metric = [0.0] * self.num
        self.records = dict()
        self.counts = dict()
1161602
public void removeAll() {
        for(Iterator<Map.Entry<MetricName, Metric>> it = metrics.entrySet().iterator(); it.hasNext();) {
            Map.Entry<MetricName, Metric> entry = it.next();
            Metric metric = entry.getValue();
            if(metric != null) {
                onMetricRemoved(entry.getKey(), metric);
            }
            it.remove();
        }
    }
710850
def reset(self, fid=0):
        
        self._checkid(fid)
        self._fitids[fid]["solved"] = False
        self._fitids[fid]["haserr"] = False
        if not self._fitids[fid]["looped"]:
            return self._fitproxy.reset(fid)
        else:
            self._fitids[fid]["looped"] = False
        return True
337928
def delete(self, measurementId):
        
        message, count, deleted = self._measurementController.delete(measurementId)
        if count == 0:
            return message, 404
        elif deleted is None:
            return message, 500
        else:
            return deleted, 200