Closes the record file.
346942
def close(self):
        """"""
        if not self.is_open:
            return
        super(MXIndexedRecordIO, self).close()
        self.fidx.close()
1272401
def _Close(self):
    
    self._fvde_volume.close()
    self._fvde_volume = None

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

    if not self._is_cached:
      close_file_system = True
    elif self._resolver_context.ReleaseFileSystem(self):
      self._is_cached = False
      close_file_system = True
    else:
      close_file_system = False

    if close_file_system:
      self._Close()
      self._is_open = False
      self._path_spec = None
287406
def close(self):
        """"""
        if not self.is_open:
            return
        if self.writable:
            check_call(_LIB.MXRecordIOWriterFree(self.handle))
        else:
            check_call(_LIB.MXRecordIOReaderFree(self.handle))
        self.is_open = False
        self.pid = None
915043
def _Close(self):
    """"""
    # pylint: disable=protected-access
    super(RawFile, self)._Close()

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

    self._file_objects = []
554263
public void close() throws IOException {
        clear();
        if (_tempfile != null) {
            _tempfile.close();
            _tempfile = null;
            _tempfilef.delete();
            _tempfilef = null;
        }
    }
1018527
def close(self):
        
        self._console_log("In close()", stack=True)
        try:
            self._close()
        finally:
            super(ConcurrentRotatingFileHandler, self).close()
911627
def close(self):
        
        if callable(getattr(self._file, 'close', None)):
            self._iterator.close()
        self._iterator = None
        self._unconsumed = None
        self.closed = True
120007
def _Close(self):
    
    if not self._file_object_set_in_init:
      self._file_object.close()
      self._file_object = None
      self._range_offset = -1
      self._range_size = -1
1335731
public void closeCurrentFile() {
    try {
      this.closer.close();
    } catch (IOException e) {
      if (this.currentFile != null) {
        LOG.error("Failed to close file: " + this.currentFile, e);
      }
    }
  }
110150
def close(self):
        
        if self._tempfile is not None:
            self._tempfile.close()
        if self._file is not None and not self._from_filelike:
            self._file.close()
683368
public void closeFile() throws JournalException {
        if (journalFile == null) {
            throw logAndGetException("Attempting to close a file "
                    + "when no file is open.");
        }

        try {
            writer.close();
            journalFile.close();
        } catch (IOException e) {
            throw logAndGetException("Problem closing the file '"
                    + journalFile.getName() + "'", e);
        }

        logger.debug("closing file: '" + journalFile.getName() + "'");
        journalFile = null;
    }
15257
public function close()
    {
        if (count($this->transactionStorageStack) > 0) {
            $this->wasClosed = true;

        } else {
            /* @var $file FileInterface */
            $file = $this->file;

            $file->close();
        }
    }
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
292156
private static void close(ReadRecord record) {
        if (record != null) {
            try {
                record.close();
            } catch (IOException e) {
                String msg = "Error while closing record.";
                log.warn(msg, e);
            }
        }
    }
495321
def close(self):
        
        super(LockingDatabase, self).close()
        if not self.readonly:
            self.release_lock()
343384
@Override
	public void close()
    {
    	// Close filesystem
        try
        {
            if (allocationTableRandomAccessFile != null)
                allocationTableRandomAccessFile.close();
        }
        catch (IOException e)
        {
            log.error("["+descriptor.getName()+"] Could not close allocation table file : "+e.toString());
        }
        try
        {
            if (dataRandomAccessFile != null)
                dataRandomAccessFile.close();
        }
        catch (IOException e)
        {
            log.error("["+descriptor.getName()+"] Could not close map file : "+e.toString());
        }
    }