Close the shelve object, which is needed for data consistency.
481101
def close(self):
        ""
        if self.is_open:
            logger.info('closing shelve data')
            try:
                self.shelve.close()
                self._shelve.clear()
            except Exception:
                self.is_open = False
1368818
def close(self):
        """"""
        self.flush()
        if self._recordio_writer is not None:
            self._recordio_writer.close()
            self._recordio_writer = None
825488
def close(self):
        '''
        '''
        try:
            self.dut.close()
        except Exception:
            logging.warning('Closing DUT was not successful')
        else:
            logging.debug('Closed DUT')
405827
def close(self):
        """"""
        if self.fp is None:
            return

        try:
            if self.mode in ('w', 'x', 'a') and self._didModify:  # write ending records
                with self._lock:
                    if self._seekable:
                        self.fp.seek(self.start_dir)
                    self._write_end_record()
        finally:
            fp = self.fp
            self.fp = None
            self._fpclose(fp)
626448
def close(self) -> None:
        """"""
        while self.wdl:
            _, wdl = self.wdl.popitem()
            wdl.close()

        while self.dtz:
            _, dtz = self.dtz.popitem()
            dtz.close()

        self.lru.clear()
615535
def close(self):
        ''''''
        h = self.gdx_handle
        gdxcc.gdxClose(h)
        gdxcc.gdxFree(h)
78607
def close(self):
        """"""
        if not hasattr(self, 'tiffs'):
            return
        for tif in self._tiffs.values():
            if tif._fd:
                tif._fd.close()
                tif._fd = None
1040066
def _Close(self):
    """"""
    if self._database_object:
      self._database_object.Close()

    self._blob = None
    self._current_offset = 0
    self._size = 0
    self._table_name = None
390502
def close(self):
        
        with self._close_lock:
            sfd = self._sfd
            if sfd >= 0:
                self._sfd = -1
                self._signals = frozenset()
                close(sfd)
667088
@Close
    public void close() {
        DatastoreConnection datastoreConnection = getDatastoreConnections().poll();
        if (datastoreConnection != null) {
            logger.info("Closing dictionary: {}", this);
            datastoreConnection.close();
        }
    }
1104035
def close(self):
        
        with self._close_lock:
            epfd = self._epfd
            if epfd >= 0:
                self._epfd = -1
                close(epfd)
203960
def close(self):
        
        files = self.__dict__.get("files")
        for _key, value in iter_multi_items(files or ()):
            value.close()
100631
def _Close(self):
    
    self._vslvm_volume_group = None
    self._vslvm_handle.close()
    self._vslvm_handle = None

    self._file_object.close()
    self._file_object = None
1021453
def close(self):
        """"""
        try:
            self.payload.close()
        except:
            pass
        try:
            self.model.close()
        except:
            pass
        try:
            self.fresh_index.close()
        except:
            pass
        try:
            self.opt_index.close()
        except:
            pass
        try:
            self.fresh_docs.terminate()
        except:
            pass
1078113
def close(self):
        """"""
        fname = os.path.basename(self._path)
        checksum_persister = _get_checksum_persister(self._path)
        with contextlib.closing(checksum_persister):
            checksum_persister[fname] = self._hasher.hexdigest()

        self._close()
182235
def close(self):
        """"""

        # remove callbacks
        Datastore.stores[self.domain].remove(self)

        # delete data after the last instance is gone
        if self.release_storage and not Datastore.stores[self.domain]:
            del Datastore.global_data[self.domain]

        del self
1027870
public void close() {
        checkOpen();

        open = false;

        for (Object arg : arguments.values()) {
            if (arg instanceof File) {
                File file = (File) arg;
                if (JournalHelper.isTempFile(file)) {
                    if (file.exists()) {
                        file.delete();
                    }
                }
            }
        }
    }