Remove links which don´t start with http.
-    * Remove old film entries which are smaller than MIN_SIZE_ADD_OLD.
557525
private void performInitialCleanup() {
        listeEinsortieren.removeIf(f -> !f.arr[DatenFilm.FILM_URL].toLowerCase().startsWith("http"));
        listeEinsortieren.removeIf(f -> {
            String groesse = f.arr[DatenFilm.FILM_GROESSE];
            if (groesse.isEmpty())
                return false;
            else {
                return Long.parseLong(groesse) < MIN_SIZE_ADD_OLD;
            }

        });
    }
106020
def remove(in_bam):
    
    if utils.file_exists(in_bam):
        utils.remove_safe(in_bam)
    if utils.file_exists(in_bam + ".bai"):
        utils.remove_safe(in_bam + ".bai")
229773
def remove_if_exists(filename):
    
    try:
        os.unlink(filename)
    except OSError as ex:
        if ex.errno != errno.ENOENT:
            raise
1064578
function () {
      var pending = 0;
      for (var url in oldLinkElements) {
        // if this sheet has any cssRules, delete the old link
        try {
          var link = currentLinkElements[url],
              oldLink = oldLinkElements[url],
              html = document.body.parentNode,
              sheet = link.sheet || link.styleSheet,
              rules = sheet.rules || sheet.cssRules;
          if (rules.length >= 0) {
            oldLink.parentNode.removeChild(oldLink);
            delete oldLinkElements[url];
            setTimeout(function () {
              html.className = html.className.replace(/\s*livejs\-loading/gi, '');
            }, 100);
          }
        } catch (e) {
          pending++;
        }
        if (pending) setTimeout(Live.removeoldLinkElements, 50);
      }
    }
384011
protected function unlinkResourceFiles()
  {
    $this->logInfo("Removing resource files");
    $count = 0;

    foreach ($this->resourceFilesInfo as $file_info)
    {
      if (isset($file_info['full_path_name_with_hash']) && isset($file_info['full_path_name']))
      {
        // Resource file has an optimized/minimized version. Remove the original file.
        if (file_exists($file_info['full_path_name']))
        {
          $this->logVerbose("Removing '%s'", $file_info['full_path_name']);
          unlink($file_info['full_path_name']);
          $count++;
        }
      }
    }

    $this->logInfo("Removed %d resource files", $count);
  }
949564
private void cleanup() {
		CacheEntry oldest = null;
		_count = 0;

		// Cleanup obsolete entries and find the oldest
		for (Map.Entry<String, CacheEntry> e : _cache.entrySet()) {
			String key = e.getKey();
			CacheEntry entry = e.getValue();
			// Remove obsolete entry
			if (entry.isExpired()) {
				_cache.remove(key);
			}
			// Count the remaining entry
			else {
				_count++;
				if (oldest == null || oldest.getExpiration() > entry.getExpiration())
					oldest = entry;
			}
		}

		// Remove the oldest if cache size exceeded maximum
		if (_count > _maxSize && oldest != null) {
			_cache.remove(oldest.getKey());
			_count--;
		}
	}
1000513
public void remove() {

    if (context == null) {
      throw new IllegalStateException("link with href=" + getHref() + " can not be removed, because it's not part of a HAL resource tree");
    }

    // iterate over all links grouped by relation (because for removal we need to know the relation)
    ListMultimap<String, Link> allLinks = context.getLinks();
    for (String relation : allLinks.keySet()) {
      List<Link> links = allLinks.get(relation);

      // use an indexed for-loop, because we need to know the index to properly remove the link
      for (int i = 0; i < links.size(); i++) {
        if (links.get(i).getModel() == model) {
          context.removeLink(relation, i);
          context = null;
          return;
        }
      }
    }

    throw new IllegalStateException("the last known context resource of link with href=" + getHref() + " no longer contains this link");
  }
1206553
private void stripLinks(final StringBuilder javaDoc) {
		int startLink = javaDoc.indexOf("{@link ");
		while (startLink != -1) {
			int endLink = javaDoc.indexOf("}", startLink) + 1;
			String link = javaDoc.substring(startLink, endLink);
			String newLink = parseLink(link);
			javaDoc.replace(startLink, endLink, newLink);
			startLink = javaDoc.indexOf("{@link ");
		}
	}
919428
def clean_up_dangling_images(self):
        
        cargoes = Image.all(client=self._client_session, filters={'dangling': True})
        for id, cargo in six.iteritems(cargoes):
            logger.info("Removing dangling image: {0}".format(id))
            cargo.delete()
163906
public function removeTmpFiles()
	{
		if (file_exists($this->getHTMLPath()))
		{
			@unlink($this->getHTMLPath());
		}
		if (file_exists($this->getPDFPath()))
		{
			@unlink($this->getPDFPath());
		}
	}
309798
def removeOldRequests
      now = Time.new
      @requestedPieces.length.times do |i|
        if @requestedPieces.set? i
          if now - @pieceRequestTime[i] > @requestTimeout
            @requestedPieces.clear i
            @pieceRequestTime[i] = nil
          end
        end
      end
    end
1231009
def clean_link(self, url):
        """"""
        return self._clean_re.sub(lambda match: "%%%2x" % ord(match.group(0)), url)
1243094
private void removeCssLinks() {
		if (this.isInit) {
			return;
		}
		this.isInit = true;
		// Remove all existing link element
		NodeList<Element> links = this.getHead().getElementsByTagName(LinkElement.TAG);
		int size = links.getLength();
		for (int i = 0; i < size; i++) {
			LinkElement elem = LinkElement.as(links.getItem(0));
			if ("stylesheet".equals(elem.getRel())) {
				elem.removeFromParent();
			}
		}
	}
296301
def cleanup(self):
        """"""
        for file in glob.glob(self.basename + '*'):
            os.unlink(file)
1077440
def _scrub_links(links, name):
    '''
    
    '''
    if isinstance(links, list):
        ret = []
        for l in links:
            ret.append(l.replace('/{0}/'.format(name), '/', 1))
    else:
        ret = links

    return ret
1228530
def cleanup(site, stitch)

      files = stitch.all_files.map{ |f| File.absolute_path(f)}
      files.concat stitch.deleted

      if files.size > 0
        site.static_files.clone.each do |sf|
          if sf.kind_of?(Jekyll::StaticFile) and files.include? sf.path
            site.static_files.delete(sf)
          end
        end
      end
    end
446799
def clean(self):
        
        #TODO: add cleaning of mask files, *if* created ...
        for f in self.catalog_names:
            if 'match' in f:
                if os.path.exists(self.catalog_names[f]):
                    log.info('Deleting intermediate match file: %s'%
                                self.catalog_names[f])
                    os.remove(self.catalog_names[f])
            else:
                for extn in f:
                    if os.path.exists(extn):
                        log.info('Deleting intermediate catalog: %d'%extn)
                        os.remove(extn)