writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });
                        writer.flush();
                    }
                });

      writerToClose = this.writer
      this.writer = null

      streamsToClose =
        when {
          writerToClose != null && reader == null -> this.streams
          else -> null
        }

      if (!isWriter && writerToClose != null) {
        // If the caller isn't the writer thread, get that thread to close the writer.
        taskQueue.execute("$name writer close", cancelable = false) {

        private boolean typed;

        /**
         * Constructor.
         *
         * @param writer a Writer object providing the underlying stream
         */
        public PropertiesWriter(Writer writer, boolean typed) {
            super(writer);
            this.typed = typed;
        }

        /**
         * Writes the given property and its value.
         *

            Consumer<String> consumer = s -> context.terminal
                    .writer()
                    .println(messageBuilderFactory.builder().info(s).build());
            if (entry.getKey() == SecDispatcher.ValidationResponse.Level.ERROR) {
                consumer = s -> context.terminal
                        .writer()
                        .println(messageBuilderFactory.builder().error(s).build());

		// Write method in io.Writer
		if m != nBytes {
			return n, io.ErrShortWrite
		}
	}
	// Buffer is now empty; reset.
	b.Reset()
	return n, nil
}

// WriteByte appends the byte c to the buffer, growing the buffer as needed.
// The returned error is always nil, but is included to match [bufio.Writer]'s
// WriteByte. If the buffer becomes too large, WriteByte will panic with

        protected File newFile;

        protected Writer writer;

        protected SynonymItem item;

        protected SynonymUpdater(final SynonymItem newItem) {
            try {
                newFile = ComponentUtil.getSystemHelper().createTempFile(SYNONYM, ".txt");
                writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(newFile), Constants.UTF_8));

    public CharSource createSource(String string) throws IOException {
      checkNotNull(string);
      File file = createFile();
      Writer writer = new OutputStreamWriter(new FileOutputStream(file), UTF_8);
      try {
        writer.write(string);
      } finally {
        writer.close();
      }
      return Files.asCharSource(file, UTF_8);
    }

    @Override
    public String getExpected(String string) {

		}

		if v.Alias != "" {
			writer.WriteString(" AS ")
			write(v.Raw, v.Alias)
		}
	case []clause.Column:
		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {
				writer.WriteByte(',')
			}
			stmt.QuoteTo(writer, d)
		}
		writer.WriteByte(')')
	case clause.Expr:
		v.Build(stmt)
	case string:
		stmt.DB.Dialector.QuoteTo(writer, v)
	case []string:
		writer.WriteByte('(')

* Fix a bug in server printer that could cause kube-apiserver to panic. ([#79349](https://github.com/kubernetes/kubernetes/pull/79349), [@roycaihw](https://github.com/roycaihw))

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Model model) throws IOException {
        try {
            delegate.write(writer, model.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);