calls clear on any report format instances created during setup
        and drops the cache
353542
def clear(self):
        

        if self._formats:
            for fmt in self._formats:
                fmt.clear()
        self._formats = None
1192979
def clear(self):
        
        for f in [x['content'] for x in self.metadata.values()]:
            os.remove(f)

        self.metadata = {}
        self._flush()
331780
def clean(all=False, docs=False, dist=False, extra=None):
    """"""

    run('find . -type f -name "*.py[co]" -delete')
    run('find . -type d -name "__pycache__" -delete')

    patterns = ['build', '*.egg-info/']
    if all or docs:
        patterns.append('doc/build/*')
    if all or dist:
        patterns.append('dist')
    if extra:
        patterns.append(extra)
    for pattern in patterns:
        run('rm -rf {}'.format(pattern))
650017
def cleanup(test_data, udfs, tmp_data, tmp_db):
    """"""
    con = make_ibis_client(ENV)

    if udfs:
        # this comes before test_data bc the latter clobbers this too
        con.hdfs.rmdir(os.path.join(ENV.test_data_dir, 'udf'))

    if test_data:
        con.drop_database(ENV.test_data_db, force=True)
        con.hdfs.rmdir(ENV.test_data_dir)

    if tmp_data:
        con.hdfs.rmdir(ENV.tmp_dir)

    if tmp_db:
        con.drop_database(ENV.tmp_db, force=True)
274154
public synchronized void clear() {
		try {
			this.storage.close();
			this.storage = provider.createStorage();
		} catch (IOException e) {
			// major fuckup
			e.printStackTrace();
		}
		this.size = 0;
	}
1189532
def clear_cache_fields(self):
        ''''''
        for field in self._meta.scalarfields:
            if field.as_cache:
                setattr(self, field.name, None)
609579
public void clearCache()
  {
    ZipFile zipFile = _zipFileRef.getAndSet(null);

    if (zipFile != null)
      try {
        zipFile.close();
      } catch (Exception e) {
      }
  }
221192
private void clearAllHeaders() {
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        if (bTrace && tc.isEntryEnabled()) {
            Tr.entry(tc, "clearAllHeaders()");
        }

        HeaderElement elem = this.hdrSequence;
        while (null != elem) {
            final HeaderElement next = elem.nextSequence;
            final HeaderKeys key = elem.getKey();
            final int ord = key.getOrdinal();
            if (storage.containsKey(ord)) {
                // first instance being removed
                if (key.useFilters()) {
                    filterRemove(key, null);
                }
                storage.remove(ord);
            }
            elem.destroy();
            elem = next;
        }
        this.hdrSequence = null;
        this.lastHdrInSequence = null;
        this.numberOfHeaders = 0;
        if (bTrace && tc.isEntryEnabled()) {
            Tr.exit(tc, "clearAllHeaders()");
        }
    }
525574
public function cleanup()
    {
        Cache::clear(false, 'default');
        Cache::clear(false, '_cake_model_');
        Cache::clear(false, '_cake_core_');
        $this->dispatchShell('orm_cache clear');
        $this->dispatchShell('orm_cache build');
    }
966826
def clear_cache(self):
        
        self.underlying_model.clear_cache()
        try:
            logger.info('DirectView results has {} items. Clearing.'.format(
                len(self._dv.results)
            ))
            self._dv.purge_results('all')
            if self._purge_client:
                self._dv.client.purge_everything()
        except:
            pass
942671
def clear():
    '''
    
    '''
    try:
        os.remove(os.path.join(__opts__['cachedir'], 'datastore'))
    except (IOError, OSError):
        pass
    return True
1171531
protected void cleanUp() {

        m_importResource = null;
        m_importZip = null;
        m_report = null;
        m_linkStorage = null;
        m_linkPropertyStorage = null;
        m_groupsToCreate = null;
        m_cms = null;
    }
939354
protected function clearCaches() {
    $config = $this->getConfiguration();
    foreach($config->getSections() as $section) {
      $sectionValues = $config->getSection($section, true);
      if (isset($sectionValues['__class'])) {
        $instance = ObjectFactory::getInstance($section);
        if ($instance instanceof Cache) {
          $instance->clearAll();
        }
        elseif ($instance instanceof View) {
          $instance->clearCache();
        }
      }
    }
  }
617153
public void clear() {
    ArrayList<Entry<K, V>> oldExclusives;
    ArrayList<Entry<K, V>> oldEntries;
    synchronized (this) {
      oldExclusives = mExclusiveEntries.clear();
      oldEntries = mCachedEntries.clear();
      makeOrphans(oldEntries);
    }
    maybeClose(oldEntries);
    maybeNotifyExclusiveEntryRemoval(oldExclusives);
    maybeUpdateCacheParams();
  }
1247655
public void clear() {
    if (cache == null) {
      return;
    }
    synchronized (cache) {
      inFlushAll = true;
      cache.invalidateAll();
      out.clear();
      inFlushAll = false;
    }
  }
665131
def clear(self):
        
        if self._customFormat:
            self._customFormat.clear()
        else:
            super(XSettings, self).clear()
618265
public void clear() {
		verifyState();

		initDepth.set(initDepth.get() - 1);
		if (initDepth.get() == 0) {
			resourceCache.set(null);
			cacheLocked.set(null);
			initDepth.set(null);
		}
	}