Closes all writers.
557755
private void close() {
		for (Writer writer : writers) {
			try {
				writer.close();
			} catch (Exception ex) {
				InternalLogger.log(Level.ERROR, ex, "Failed to close writer");
			}
		}
	}
712144
@Override
    public void close()
    {
        if(workbook != null)
            workbook.close();

        try
        {
            if(writableWorkbook != null)
                writableWorkbook.close();
        }
        catch(IOException e)
        {
        }
        catch(WriteException e)
        {
        }
    }
894069
public void close() {
    if (lock != null) {
      lock.lock();
    }
    this.connected = false;
    try {
      /* If a streaming result set is open, close it.*/
      skip();
    } catch (Exception e) {
      /* eat exception */
    }

    SendClosePacket.send(writer);
    closeSocket(reader, writer, socket);
    cleanMemory();
    if (lock != null) {
      lock.unlock();
    }
  }
445418
public function close()
	{
		$writer = PHPExcel_IOFactory::createWriter( $this->_container, $this->_format );
		$writer->save( $this->_resourcepath );
	}
142280
@Override
    public void stop() {

        // Make sure to return the system streams to the state they were in
        // before we mucked with them
        restoreSystemStreams();

        unregisterLoggerHandlerSingleton();

        // Close writers, however they were allocated
        LoggingFileUtils.tryToClose(messagesLog);
        LoggingFileUtils.tryToClose(traceLog);
    }
977091
def close_all(self):
        """"""
        for host, conns in self._cm.get_all().items():
            for h in conns:
                self._cm.remove(h)
                h.close()
1076788
def close(self):
        """"""
        if self._closing or self._handle.closed:
            return
        self._closing = True
        self._write_backlog.append([b'', False])
        self._process_write_backlog()
339245
def abort(self):
        
        if self._closed:
            return
        self._closed = True
        self._writer.flush()
        del self._writer
1298809
private void flush(final Collection<Writer> writers) {
		for (Writer writer : writers) {
			try {
				writer.flush();
			} catch (Exception ex) {
				InternalLogger.log(Level.ERROR, ex, "Failed to flush writer");
			}
		}
	}
205314
def close_all():
    """"""
    for key, p in _ALL_PLOTTERS.items():
        p.close()
    _ALL_PLOTTERS.clear()
    return True
219146
@Override
  public final void close()
      throws IOException {
    try {
      // end collection
      writer.writeEndCollection()
          .writeEndDocument()
          .close();
    } catch (XMLStreamException e) {
      throw new IOException(e.getMessage());
    }
  }
896164
def close(self):
        """"""
        logger('HttpConnection').debug('Closing connection....')
        self.writer.close()
        self._closed = True
1199512
@Override
  public synchronized void close() {
    // try to write everything queued / buffered
    for (BatchPoints points : batchQueue) {
      WriteResult result = tryToWrite(points);
      if (result.outcome != WriteResultOutcome.WRITTEN) {
        exceptionHandler.accept(points.getPoints(), result.throwable);
      }
    }
  }
389410
def close(self):
        """"""
        if self._writer:
            self._writer.transport.close()
        self._writer = None
        self._reader = None
439499
def close(self):
        """"""
        if self._writer is not None:
            self.flush()
            self._writer.close()
            self._writer = None
943238
public void close() throws IOException {
		writer.write("</rdf:RDF>");
		writer.write("</x:xmpmeta>\n");
		for (int i = 0; i < extraSpace; i++) {
			writer.write(EXTRASPACE);
		}
		writer.write(end == 'r' ? XPACKET_PI_END_R : XPACKET_PI_END_W);
		writer.flush();
		writer.close();
	}
1015085
def _Close(self):
    """"""
    self._fsntfs_data_stream = None
    self._fsntfs_file_entry = None

    self._file_system.Close()
    self._file_system = None