Clear all cached data.

    Parameters
    ----------
    scope : {None, 'step', 'iteration', 'forever'}, optional
        Clear cached values with a given scope.
        By default all cached values are removed.
541377
def clear_cache(scope=None):
    
    if not scope:
        _TABLE_CACHE.clear()
        _COLUMN_CACHE.clear()
        _INJECTABLE_CACHE.clear()
        for m in _MEMOIZED.values():
            m.value.clear_cached()
        logger.debug('pipeline cache cleared')
    else:
        for d in (_TABLE_CACHE, _COLUMN_CACHE, _INJECTABLE_CACHE):
            items = tz.valfilter(lambda x: x.scope == scope, d)
            for k in items:
                del d[k]
        for m in tz.filter(lambda x: x.scope == scope, _MEMOIZED.values()):
            m.value.clear_cached()
        logger.debug('cleared cached values with scope {!r}'.format(scope))
801899
def clear(self, store=True):
        
        result = self._iface.ach_lock(self.name)
        result and store and self._store()
        return result
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
416223
def clear(self) -> None:
        
        if self._cache_directory is not None:
            # Safety - if there isn't a cache directory file, this probably isn't a valid cache
            assert os.path.exists(self._cache_directory_index), "Attempt to clear a non-existent cache"
            self._load()            # Shouldn't have any impact but...
            for e in self._cache.values():
                if os.path.exists(e.loc):
                    os.remove(e.loc)
            self._cache.clear()
            self._update()
        self._cache = {}
873956
def clear_cached(self):
        
        _TABLE_CACHE.pop(self.name, None)
        for col in _columns_for_table(self.name).values():
            col.clear_cached()
        logger.debug('cleared cached columns for table {!r}'.format(self.name))
671984
public void clear() {
	new ByteArrayList(this.state).fillFromToWith(0, this.state.length-1, FREE);
	//new DoubleArrayList(values).fillFromToWith(0, state.length-1, 0); // delta
	
	/*
	if (debug) {
		for (int i=table.length; --i >= 0; ) {
		    state[i] = FREE;
		    table[i]= Integer.MAX_VALUE;
		    values[i]= Double.NaN;
		}
	}
	*/
	
	this.distinct = 0;
	this.freeEntries = table.length; // delta
	trimToSize();
}
828192
public void uninit() {
        log.debug("Un-init scope");
        for (IBasicScope child : children.keySet()) {
            if (child instanceof Scope) {
                ((Scope) child).uninit();
            }
        }
        stop();
        setEnabled(false);
        if (hasParent()) {
            if (parent.hasChildScope(name)) {
                parent.removeChildScope(this);
            }
        }
    }
999947
def clear(self):
        
        self.__values.clear()
        self.__access_keys = []
        self.__modified_times.clear()
61728
public void clearCache()
  {
    // XXX: see if can remove this, and rely on the invocation cache existing
    LruCache<Object,I> invocationCache = _invocationCache;

    if (invocationCache != null) {
      invocationCache.clear();
    }
  }
103601
@Override
    public void clear() {
        Map<String, GroovyRunner> map = getMap();
        writeLock.lock();
        try {
            cachedValues = null;
            map.clear();
            loadDefaultRunners();
        } finally {
            writeLock.unlock();
        }
    }
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
742803
def clean(self):
        
        data = self.cleaned_data
        want_scope = data.get('scope') or 0
        grant = data.get('grant')
        has_scope = grant.scope if grant else 0

        # Only check if we've actually got a scope in the data
        # (read: All fields have been cleaned)
        if want_scope is not 0 and not scope.check(want_scope, has_scope):
            raise OAuthValidationError({'error': 'invalid_scope'})

        return data
974305
def clear(self, scope = 'screen'):
        
        #TODO: clear attributes too
        if scope == 'screen':
            bos = (0, self._get_console_info()['window']['top'])
            cols, lines = self.get_size()
            length = cols * lines
            self._clear_console(length, bos)
            self.move('beginning of screen')
        elif scope == ' beginning of line':
            pass
        elif scope == 'end of line':
            curx, cury = self._get_position()
            cols, lines = self.get_size()
            coord = (curx, cury)
            length = cols - curx
            self._clear_console(length, coord)
        elif scope == 'end of screen':
            curx, cury = self._get_position()
            coord = (curx, cury)
            cols, lines = self.get_size()
            length = (lines - cury) * cols - curx
            self._clear_console(length, coord)
        elif scope == 'line':
            curx, cury = self._get_position()
            coord = (0, cury)
            cols, lines = self.get_size()
            self._clear_console(cols, coord)
            self._set_position((curx, cury))
        elif scope == 'left':
            self.move('left')
            self.write(' ')
        elif scope == 'right':
            self.write(' ')
            self.move('left')
        else:
            raise ValueError("invalid scope to clear")
399537
def clear(self):
        """"""
        io_loop = IOLoop.current()
        while self._tombstones:
            _, req_timeout = self._tombstones.popitem()
            io_loop.remove_timeout(req_timeout)
1357125
public void clearCache()
  {
    // skip the clear on restart
    if (_lifecycle.isStopping()) {
      return;
    }

    if (log.isLoggable(Level.FINER)) {
      log.finest("clearCache");
    }

    // the invocation cache must be cleared first because the old
    // filter chain entries must not point to the cache's
    // soon-to-be-invalid entries
    getInvocationManager().clearCache();

    /*
    if (_httpCache != null) {
      _httpCache.clear();
    }
    */
  }
1243058
def clear_cached(self):
        
        x = _COLUMN_CACHE.pop((self.table_name, self.name), None)
        if x is not None:
            logger.debug(
                'cleared cached value for column {!r} in table {!r}'.format(
                    self.name, self.table_name))
512380
def _clear(self):
        
        self.__names.clear()
        self.__queue.clear()
        self.__context = None