Remove file from interface
762225
public function unlink($path)
	{
		if(isset(static::$pointer_tree[$path_to]))
		{
			if(is_resource(static::$pointer_tree[$path_to]))
				fclose(static::$pointer_tree[$path_to]);
			
			unset(static::$pointer_tree[$path_to]);
		}
		
		return true;
	}
964027
def remove(self, pattern):
        """"""
        assert isinstance(pattern, Pattern)
        self.patterns.remove(pattern)
        self._all_files = None
692369
def remove(self, uid, filename=None):
        
        book = ConfigParser(default_section='format')
        with self._lock:
            book.read(self._filename)
            del book[uid.split('@')[0]]
            with open(self._filename, 'w') as fp:
                book.write(fp, False)
278108
function remove(conf) {
  var file = conf.get(ConfigKey.PIDFILE);
  // can be the empty string
  if(file) {
    log.notice('removing pid file %s', file);
    try {
      fs.unlinkSync(file);
    }catch(e) {
      log.warning('failed to remove pid file (%s): %s', file, e.message);
    }
  }
}
102486
def remove_file(self, file_name, *args, **kwargs):
		
		client = self.dav_client()
		remote_path = self.join_path(self.session_path(), file_name)
		if client.is_dir(remote_path) is True:
			raise ValueError('Unable to remove non-file entry')
		client.clean(remote_path)
724274
def file_delete(context, id, file_id):
    
    dci_file.delete(context, id=file_id)
    result = dci_file.delete(context, id=file_id)
    utils.format_output(result, context.format)
438656
def remove_file(path, remove=os.remove, exists=os.path.exists):
    """"""
    try:
        remove(path)
    except OSError:
        if exists(path):
            raise
719521
def delete(self):
        '''  '''
        self.down()
        fcntl.ioctl(ifconfig.sockfd, SIOCBRDELBR, self.name)
        return self
1132946
def delete(self, filething=None):
        

        fileobj = filething.fileobj

        self.tags.clear()
        # TODO: we should delegate the deletion to the subclass and not through
        # _inject.
        try:
            try:
                self.tags._inject(fileobj, lambda x: 0)
            except error as e:
                reraise(self._Error, e, sys.exc_info()[2])
            except EOFError:
                raise self._Error("no appropriate stream found")
        except IOError as e:
            reraise(self._Error, e, sys.exc_info()[2])
181659
def remove(self):
        
        from fs.errors import ResourceNotFoundError

        try:
            self._fs.remove(self.file_name)
        except ResourceNotFoundError:
            pass
822972
public void removeFile(final OFileMMap iFile) {
    lockManager.acquireLock(Thread.currentThread(), iFile, OLockManager.LOCK.EXCLUSIVE);
    try {
      mapEntrySearchInfo.remove(iFile);
      final OMMapBufferEntry[] entries = bufferPoolPerFile.remove(iFile);
      removeFileEntries(entries);
    } finally {
      lockManager.releaseLock(Thread.currentThread(), iFile, OLockManager.LOCK.EXCLUSIVE);
    }
  }
384934
def _Close(self):
    """"""
    # pylint: disable=protected-access
    super(EWFFile, self)._Close()

    for file_object in self._file_objects:
      file_object.close()

    self._file_objects = []
85989
def delete(key, parameters = {})
      if File.file?(path = pathify(key, parameters))
        FileUtils.rm(path)
      end
    end
81843
def remove(self, *args):
        

        key = self.get_storage_key(*args)
        pk = self.instance.pk.get()
        logger.debug("removing %s from index %s" % (pk, key))
        self.connection.srem(key, pk)
        self._deindexed_values.add(tuple(args))
783587
def file_delete(context, id, file_id):
    
    component.file_delete(context, id=id, file_id=file_id)
434107
public void remove(int idx) {
        size--;
        System.arraycopy(data, idx + 1, data, idx, size - idx);
    }
909022
def remove_resource_file(issue, filepath, ignore_layouts):
    
    if os.path.exists(filepath) and (ignore_layouts is False or issue.elements[0][0] != 'layout'):
        print('removing resource: {0}'.format(filepath))
        os.remove(os.path.abspath(filepath))