Closes the Workbook manually.
174199
public void close() {
    try {
      if (is != null) is.close();
    } catch (IOException e) {
      log.error(null, e);
      throw new RuntimeException(e);
    }
    isClosed = true;
  }
721547
def close(self):
        
        # This may not be absolutely necessary, but it is safe.
        # It's the closest thing to a close() method.
        if self._dev is not None:
            usb.util.dispose_resources(self._dev)
            self._dev = None
506193
def _Close(self):
    """"""
    self._tar_ext_file.close()
    self._tar_ext_file = None

    self._file_system.Close()
    self._file_system = None
12068
def close(self):
        
        os.remove(self._file)
        os.rmdir(self._dir)
        self.thread._exit = True
        self.thread.join(1000)
        self._close()
897954
def manual_close(self):
        
        if self.is_closed():
            return False

        # Obtain reference to the connection in-use by the calling thread.
        conn = self.connection()

        # A connection will only be re-added to the available list if it is
        # marked as "in use" at the time it is closed. We will explicitly
        # remove it from the "in use" list, call "close()" for the
        # side-effects, and then explicitly close the connection.
        self._in_use.pop(self.conn_key(conn), None)
        self.close()
        self._close(conn, close_conn=True)
993548
def _Close(self):
    
    if not self._file_object_set_in_init:
      self._file_object.close()
      self._file_object = None

    self._decoder = None
    self._decoded_data = b''
    self._encoded_data = b''
383321
def close(self):
        
        if not self.closed and not self.closing:
            logger.debug(
                "%s[%s] closing...",
                self.__class__.__name__,
                id(self),
            )
            self._closing.set()
            future = asyncio.ensure_future(self.on_close(), loop=self.loop)
            future.add_done_callback(self._set_closed)
203480
public function close()
    {
        $writer = IOFactory::createWriter($this->phpExcelObject, 'Xlsx');
        //\PHPExcel_IOFactory::createWriter($this->phpExcelObject, 'Excel2007');
        $writer->save($this->filename);
    }
1200769
def close(self):
        
        self.cell = None
        self.coro = None
        self.buffer = None
        del self.dests[:]
        del self.sources[:]
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])
1368818
def close(self):
        """"""
        self.flush()
        if self._recordio_writer is not None:
            self._recordio_writer.close()
            self._recordio_writer = None
116538
@Override
public void close() throws IOException {
	try {
		// prepare metadata
		prepareMetaData();
		
		// write
		if (this.oStream!=null) {
			if (this.howc.getPassword()==null) { // no encryption
				finalizeWriteNotEncrypted();
			} else 	// encryption
				if (this.currentWorkbook instanceof HSSFWorkbook) { // old Excel format
					finalizeWriteEncryptedHSSF();
				} else if (this.currentWorkbook instanceof XSSFWorkbook) {
					finalizeWriteEncryptedXSSF();
					}
				 else {
					LOG.error("Could not write encrypted workbook, because type of workbook is unknown");
				}

			}
		} finally {

			// close filesystems
			if (this.ooxmlDocumentFileSystem!=null)  {
				 ooxmlDocumentFileSystem.close();
			}

		// close main workbook
		if (this.currentWorkbook!=null) {
			this.currentWorkbook.close();
		}
		
		// close linked workbooks
		 	for (Workbook currentWorkbookItem: this.listOfWorkbooks) {
				if (currentWorkbookItem!=null) {
					currentWorkbookItem.close();
				}
			}
		}
	try {
	// do we need to sign => sign
	if (this.signUtil!=null) {
		// sign
		LOG.info("Signing document \""+this.howc.getFileName()+"\"");
		if (this.howc.getSigCertificate()==null) {
			LOG.error("Cannot sign document \""+this.howc.getFileName()+"\". No certificate for key provided");
		} else if (!(this.currentWorkbook instanceof XSSFWorkbook)){
			LOG.warn("Signing of docuemnts in old Excel format not supported for \""+this.howc.getFileName()+"\"");
		}else {
		try {
				ArrayList<X509Certificate> certList = new ArrayList<>();
				certList.add(this.howc.getSigCertificate());
				this.signUtil.sign(this.howc.getSigKey(), certList, this.howc.getPassword(), MSExcelWriter.getHashAlgorithm(this.howc.getSigHash()));
		} catch (XMLSignatureException|MarshalException|IOException|FormatNotUnderstoodException e) {
			LOG.error("Cannot sign document \""+this.howc.getFileName()+"\" "+e);
		}
			
		}
		
	}
	} finally {
		if (this.signUtil!=null) {
			this.signUtil.close();
		}
	}
}
835254
def _Close(self):
    """"""
    self._tsk_attribute = None
    self._tsk_file = None

    self._file_system.Close()
    self._file_system = None
1017970
public function close()
    {
        if (!$this->isWriterOpened) {
            return;
        }

        $this->closeWriter();

        if (is_resource($this->filePointer)) {
            $this->globalFunctionsHelper->fclose($this->filePointer);
        }

        $this->isWriterOpened = false;
    }
457886
def _Close(self):
    
    self._vshadow_volume.close()
    self._vshadow_volume = None

    self._file_object.close()
    self._file_object = None
318416
def close(self, *args, **kwargs):
        
        if not self.__finalized:
            self._file.write('</cml>')
            self.__finalized = True
        super().close(*args, **kwargs)
963160
public synchronized void close() {
        if (mIsInitializing) throw new IllegalStateException("Closed during initialization");

        if (mDatabase != null && mDatabase.isOpen()) {
            mDatabase.close();
            mDatabase = null;
        }
    }