//
// If the writer gets ahead of the reader, so that the buffer fills,
// future writes are discarded and replaced in the output stream by an
// overflow entry, which has size 2+hdrsize+1, time set to the time of
// the first discarded write, a header of all zeroed words, and a "stack"
// containing one word, the number of discarded writes.
//

	"k8s.io/kubernetes/cmd/kubeadm/app/util/patches"
)

// WriteConfigToDisk writes the kubelet config object down to a file
// Used at "kubeadm init" and "kubeadm upgrade" time
func WriteConfigToDisk(cfg *kubeadmapi.ClusterConfiguration, kubeletDir, patchesDir string, output io.Writer) error {
	kubeletCfg, ok := cfg.ComponentConfigs[componentconfigs.KubeletGroup]
	if !ok {

            @Override
            public void write(OutputStream outputStream) {
                String types = filteredRequests.stream()
                    .map(request -> request.getInterceptedCallable().getOwner().getType().getClassName().replace(".", "/"))
                    .distinct()
                    .sorted()
                    .collect(Collectors.joining("\n"));

const serializationHeader = "GO PREPROFILE V1\n"

// WriteTo writes a serialized representation of Profile to w.
//
// FromSerialized can parse the format back to Profile.
//
// WriteTo implements io.WriterTo.Write.
func (d *Profile) WriteTo(w io.Writer) (int64, error) {
	bw := bufio.NewWriter(w)

	var written int64

	// Header
	n, err := bw.WriteString(serializationHeader)
	written += int64(n)
	if err != nil {
		return written, err

// buffer. This builder does not reallocate the output buffer. Writes that
// would exceed the buffer's capacity are treated as an error.
func NewFixedBuilder(buffer []byte) *Builder {
	return &Builder{
		result:    buffer,
		fixedSize: true,
	}
}

// SetError sets the value to be returned as the error from Bytes. Writes
// performed after calling SetError are ignored.
func (b *Builder) SetError(err error) {

		nodeName = cfg.Name
	}
	if name, idx := kubeadmapi.GetArgValue(cfg.KubeletExtraArgs, "hostname-override", -1); idx > -1 {
		nodeName = name
	}
	return nodeName, hostname, err
}

// WriteKubeletDynamicEnvFile writes an environment file with dynamic flags to the kubelet.
// Used at "kubeadm init" and "kubeadm join" time.

     */
    byte getVersion();

    /**
     * Returns the initial state for a lock file with this format.
     */
    LockState createInitialState();

    /**
     * writes the state data
     */
    void write(DataOutput lockFileAccess, LockState lockState) throws IOException;

    /**
     * reads the state data
     */
    LockState read(DataInput lockFileAccess) throws IOException;

     */
    T read(Decoder decoder) throws EOFException, Exception;

    /**
     * Writes the given object to the given stream. The implementation must not perform any buffering.
     */
    void write(Encoder encoder, T value) throws Exception;

	"istio.io/istio/pkg/test"
)

type docType string

const (
	namespacesAndCRDs docType = "namespaces_and_crds"
	misc              docType = "misc"
)

// FileWriter write YAML content to files.
type FileWriter interface {
	// WriteYAML writes the given YAML content to one or more YAML files.
	WriteYAML(filenamePrefix string, contents ...string) ([]string, error)

 */

package org.gradle.platform.base.internal.toolchain;

import org.gradle.internal.logging.text.DiagnosticsVisitor;

public interface ToolSearchResult {
    boolean isAvailable();

    /**
     * Writes some diagnostics about why the tool is not available.
     */
    void explain(DiagnosticsVisitor visitor);