Reset sort state, set collection and emit resetModel signal
421145
def set_collection(self, collection):
        """"""
        self.beginResetModel()
        self.collection = collection
        self.sort_state = (-1, False)
        self.endResetModel()
1029395
function(model) {
		var _d = this._d; // quicker lookup
		if (!_d.hasData) {
			// if we've never rendered data yet, queue up a reset collection
			// this probably means we just finished our very first fetch
			// reset needed to clear out loading / no data state..
			return this.resetCollection();
		}
		_d.modelChanges[model.cid] = {t: 'add', m: model};
		this.updateViews();
	}
1107432
protected void reset() {
	done.set(false);
	performing.set(false);
	cancelled.set(false);
	estimated.set(0L);
    }
719690
function _reset() {
  this._queue = [];
  this._commands = [{cmd: Constants.MAP.multi.name, args: []}];
  this._multi = false;
}
91830
public void resetSort() {
        final ValueExpression origSortBy = (ValueExpression) getStateHelper().get(PropertyKeys.origSortBy);
        // Set sort by even if null to restore to initial sort order.
        setSortByValueExpression(origSortBy);

        final String origSortOrder = (String) getStateHelper().get(PropertyKeys.origSortOrder);
        if (origSortOrder != null) {
            setSortOrder(origSortOrder);
        }
    }
1333939
final public function clearCollection()
    {
        $reset = [
            &$this->collection,
            &$this->collectionRaw,
        ];

        foreach ($reset as &$property) {
            $property = [];
        }
    }
26807
def reset(self):
        
        if self._status is not TaskStatus.STOPPED:
            raise RuntimeError("Cannot reset %s in state %s" %
                               (self, self._status))
        self._reset()
        self.return_values = {}
        self._status = TaskStatus.IDLE
766825
void reset() {

        if (this.keys == null) {
            this.len = Integer.MIN_VALUE;
            this.mask = Integer.MIN_VALUE;
            this.threshold = Integer.MIN_VALUE;
            this.count = Integer.MIN_VALUE;
            for (int i = 0; i < 3; i++) {
                this.ints[i] = Integer.MIN_VALUE;
            }
            this.map = null;
        } else {
            this.keys = new Object[this.keys.length];
        }

        this.count = 0;

    }
1050619
def reload(self):
        
        new_model = self.collection.get(self.id)
        self.attrs = new_model.attrs
813590
def reset(self):
        '''
        
        '''
        self._current_index = -1
        self._current_value = self._default_value
        self._current_rendered = self._default_rendered
        self.offset = None
67849
public void reset() {
    final int ceilingLgK = Util.toLog2(Util.ceilingPowerOf2(reservoirSize_), "ReservoirItemsSketch");
    final int initialLgSize =
            SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);

    currItemsAlloc_ = SamplingUtil.getAdjustedSize(reservoirSize_, 1 << initialLgSize);
    data_ = new ArrayList<>(currItemsAlloc_);
    itemsSeen_ = 0;
  }
265892
protected function reset()
    {
        $this->action     = null;
        $this->collection = null;
        $this->ident      = null;
    }
1003750
function(options) {
          options = options ? _.clone(options) : {};
          if (options.parse === void 0) { options.parse = true; }
          var success = options.success;
          var collection = this;
          options.success = function(resp) {
            var arr = [];
            var keys = _.keys(resp);
            _.each(keys, function(key) {
              arr.push(resp[key]);
            });
            var method = options.reset ? 'reset' : 'set';
            collection[method](arr, options);
            if (success) { success(collection, arr, options); }
            options.autoSync = false;
            options.url = this.url;
            collection.trigger('sync', collection, arr, options);
          };
          return this.sync('read', this, options);
        }
215414
function(options) {
      options || (options = {});
      var collection = this;
      var success = options.success;
      options.success = function(resp, status, xhr) {
        collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options);
        if (success) success(collection, resp);
      };
      options.error = wrapError(options.error, collection, options);
      return (this.sync || Backbone.sync).call(this, 'read', this, options);
    }
143799
function () {
				var pReset, oMsr = startMeasurements("reset");
				Log.debug("Cache Manager: Reset called.");

				pReset = this._callInstanceMethod("reset", arguments).then(function callInstanceHandler() {
					Log.debug("Cache Manager: Reset completed successfully.");
					oMsr.endAsync();
					//nothing to return, just logging.
				}, function (e) {
					Log.debug("Cache Manager: Reset failed. Error: " + e);
					oMsr.endAsync();
					throw e;
				});
				oMsr.endSync();
				return pReset;
			}
189339
def reset(self, newval):
        '''
        
        '''
        oldval = self._state.get()
        self._state.set(newval)
        self.notify_watches(oldval, newval)
        return newval
199146
def emitSortingChanged( self, index ):
        
        if not self.signalsBlocked() and self.isSortingEnabled():
            self.sortingChanged.emit(index, self.header().sortIndicatorOrder())