Closes this file.
491738
@Override
  public void close() {
    try {
      super.close();
      if(!emptyPages.isEmpty() && header instanceof TreeIndexHeader) {
        // write the list of empty pages to the end of the file
        ((TreeIndexHeader) header).writeEmptyPages(emptyPages, file);
      }
      ((TreeIndexHeader) header).setLargestPageID(nextPageID);
      header.writeHeader(file);
      file.close();
    }
    catch(IOException e) {
      throw new RuntimeException(e);
    }
  }
1312454
def close(self):
        
        if self.fileobj is None:
            return
        if self.mode == WRITE:
            self.close_member()
            self.fileobj = None
        elif self.mode == READ:
            self.fileobj = None
            
        if self.myfileobj:
            self.myfileobj.close()
            self.myfileobj = None
415137
def close(self):
        """"""
        self._filesystem.open_files[self.filedes].remove(self)
        os.close(self.fd)
813673
def _Close(self):
    """"""
    if self._zip_ext_file:
      self._zip_ext_file.close()
      self._zip_ext_file = None

    self._zip_file = None
    self._zip_info = None

    self._file_system.Close()
    self._file_system = None
1320397
def close(self):
        """"""
        
        if self.filepath is not None:
            if path.isfile(self.filepath+'.lock'):
                remove(self.filepath+'.lock')
            self.filepath = None
            self.read_only = False
            self.lock()
            return True
        else:
            raise KPError('Can\'t close a not opened file')
1232863
public void close() {

        try {
            rwLock.writeLock().lock();
            closeNoRWLock();
        } finally {
            rwLock.writeLock().unlock();
        }

        if (this.deleteDiskFiles) {
            deleteDiskCacheFiles();
            this.deleteDiskFiles = false;
        }
    }
33269
@Override
    public void close() throws IOException
    {
        if (out != null)
        {
            out.close();
            out = null;
        }
        if (in != null)
        {
            in.close();
            in = null;
        }
    }
936230
def close(self):
        ''''''
        if self._connection:
            self._connection_file.close()
            self._connection_file = None
            self._connection.close()
            self._connection = None
1017693
def _Close(self):
    
    self._bde_volume.close()
    self._bde_volume = None

    self._file_object.close()
    self._file_object = None
731528
def close(self):
    
    if not self._is_open:
      raise IOError('Not opened.')

    if not self._is_cached:
      close_file_object = True
    elif self._resolver_context.ReleaseFileObject(self):
      self._is_cached = False
      close_file_object = True
    else:
      close_file_object = False

    if close_file_object:
      self._Close()
      self._is_open = False
203960
def close(self):
        
        files = self.__dict__.get("files")
        for _key, value in iter_multi_items(files or ()):
            value.close()
1161850
public void close() {
        logger.debug("Try to close accessFile and channel for file: " + osFile);
        if (headerBuffer != null) {
            headerBuffer.force();
            headerBuffer = null;
        }

        try {
            unlock();
            if (channel != null && channel.isOpen()) {
                channel.close();
                channel = null;
            }

            if (accessFile != null) {
                accessFile.close();
                accessFile = null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        logger.debug("Closed accessFile and channel for file: " + osFile);
    }
1028556
def close(self):
        
        self.closed = True
        self._flush_bits_to_stream()
        self._stream.close()
1020492
def _Close(self):
    
    if not self._file_object_set_in_init:
      self._file_object.close()
      self._file_object = None

    self._compressed_data = b''
    self._uncompressed_data = b''
    self._decompressor = None
36523
@Override
    public void close()
            throws IOException
    {
        compressed = null;
        uncompressed = null;
        if (in != null) {
            in.close();
        }
    }
1231406
def close(self):
        """"""
        if not self.active:
            return

        self.active = False
        if self._file:
            self._file.close()
            self._sincedb_update_position(force_update=True)

        if self._current_event:
            event = '\n'.join(self._current_event)
            self._current_event.clear()
            self._callback_wrapper([event])
885439
public void close() {
        if (this.m_stream != null) {
            try {
                this.m_stream.close();
                this.m_stream = null;
            } catch (IOException e) {
                logger.warn("Error closing stream", e);
            }
        }
    }