return
	}
	// write "Name"
	err = en.Append(0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "Purge"
	err = en.Append(0xa5, 0x50, 0x75, 0x72, 0x67, 0x65)
	if err != nil {
		return
	}
	// map header, size 1
	// write "RetainVersions"

	// TODO
	return nil
}

func (c *ConfigWriter) PrintFullSummary() error {
	_, _ = c.Stdout.Write([]byte("\n"))
	if err := c.PrintWorkloadSummary(WorkloadFilter{}); err != nil {
		return err
	}
	_, _ = c.Stdout.Write([]byte("\n"))
	if err := c.PrintServiceSummary(ServiceFilter{}); err != nil {
		return err
	}
	_, _ = c.Stdout.Write([]byte("\n"))
	if err := c.PrintPolicySummary(PolicyFilter{}); err != nil {
		return err
	}

      bytesLeft -= toWrite
      delegate.write(source, toWrite)
    }
  }

		return
	}
	// write "Bytes"
	err = en.Append(0xa5, 0x42, 0x79, 0x74, 0x65, 0x73)
	if err != nil {
		return
	}
	err = en.WriteFloat64(z.Curr.Bytes)
	if err != nil {
		err = msgp.WrapError(err, "Curr", "Bytes")
		return
	}
	// write "aq"
	err = en.Append(0xa2, 0x61, 0x71)
	if err != nil {
		return
	}
	// map header, size 2
	// write "Count"

   * {@code Writer}. When the returned {@code OutputStream} is closed, so is the backing {@code
   * Writer}.
   */
  @J2ktIncompatible
  @GwtIncompatible // Writer,OutputStream
  public abstract OutputStream encodingStream(Writer writer);

  /**
   * Returns a {@code ByteSink} that writes base-encoded bytes to the specified {@code CharSink}.
   */
  @J2ktIncompatible

    @Override
    public void write(Writer output, Map<String, Object> options, PersistedToolchains toolchains) throws IOException {
        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(toolchains, "toolchains cannot be null");

        try (Writer out = output) {
            new MavenToolchainsStaxWriter().write(out, toolchains.getDelegate());

// implementation which is buggy on NUMA systems, we have to use a simpler
// io.Writer implementation alone avoids also unnecessary buffer copies,
// and as such incurred latencies.
var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}

func (discard) Write(p []byte) (int, error) {
	return len(p), nil
}

// DiscardReader discarded reader

	// write "bs"
	err = en.Append(0xa2, 0x62, 0x73)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.Bytes)
	if err != nil {
		err = msgp.WrapError(err, "Bytes")
		return
	}
	// write "par"
	err = en.Append(0xa3, 0x70, 0x61, 0x72)
	if err != nil {
		return
	}
	err = en.WriteBool(z.Participating)
	if err != nil {
		err = msgp.WrapError(err, "Participating")
		return
	}
	// write "inf"

  }

  public void testNullWriter() throws Exception {
    // create a null writer
    Writer nullWriter = CharStreams.nullWriter();
    // write to the writer
    nullWriter.write('n');
    String test = "Test string for NullWriter";
    nullWriter.write(test);
    nullWriter.write(test, 2, 10);
    nullWriter.append(null);
    nullWriter.append(null, 0, 4);

  }

  public void testNullWriter() throws Exception {
    // create a null writer
    Writer nullWriter = CharStreams.nullWriter();
    // write to the writer
    nullWriter.write('n');
    String test = "Test string for NullWriter";
    nullWriter.write(test);
    nullWriter.write(test, 2, 10);
    nullWriter.append(null);
    nullWriter.append(null, 0, 4);