class MyTask extends DefaultTask {
    @Nested
    TextResource config

    @OutputFile
    File output

    @TaskAction
    void generate() {
        getOutput().text = getConfig().asString()
    }
}

def generateConfigFile = tasks.register("generateConfigFile") {
    outputs.file "config.txt"
    doLast {
        file("config.txt").text = "my config"
    }
}

task generateConfigZip(type: Zip) {

        return actionExecution.empty ? null : Iterables.getOnlyElement(actionExecution)
    }

    String buildCacheKeyFor(String identity) {
        def execution = transformExecutions.find { it.details.identity == identity }
        def snapshotExecution = snapshotInputsOperation(execution).result
        return snapshotExecution.hash as String
    }

    void enableIdentityCache() {
        // So we don't get a daemon from another test

               const std::string& op_name, const std::string& send_device,
               const std::string& recv_device,
               tensorflow::uint64 send_device_incarnation);

// Return a RecvOp op `op_name` with the attributes `send_device`,
// `recv_device`, and `send_device_incarnation` set.
TFE_Op* RecvOp(TFE_Context* ctx, const std::string& op_name,

    def "can use char source text resource"() {
        when:
        def r = new CharSourceBackedTextResource("display name", CharSource.wrap("foo"))

        then:
        r.asString() == "foo"
        r.asReader().text == "foo"
    }

		for i := 0; i < b.N; i++ {
			for _, kv := range vs {
				kv.Visit(v)
			}
		}
	})
}

type setVisitor struct {
	i int64
	s string
	b bool
	u uint64
	d time.Duration
	f float64
	a any
}

func (v *setVisitor) String(s string)          { v.s = s }
func (v *setVisitor) Int64(i int64)            { v.i = i }
func (v *setVisitor) Uint64(x uint64)          { v.u = x }

				}
			}
		}
	}

	return nil
}

func cstring(b []byte) string {
	i := bytes.IndexByte(b, 0)
	if i == -1 {
		i = len(b)
	}
	return string(b[0:i])
}

// Segment returns the first Segment with the given name, or nil if no such segment exists.
func (f *File) Segment(name string) *Segment {
	for _, l := range f.Loads {
		if s, ok := l.(*Segment); ok && s.Name == name {

    }

    @Override
    public UniqueId read(Decoder decoder) throws Exception {
        String string = decoder.readString();
        return UniqueId.from(string);
    }

    @Override
    public void write(Encoder encoder, UniqueId value) throws Exception {
        encoder.writeString(value.asString());
    }

// in sh.Name, but if it is longer then 8 characters, it is stored
// in COFF string table st instead.
func (sh *SectionHeader32) fullName(st StringTable) (string, error) {
	if sh.Name[0] != '/' {
		return cstring(sh.Name[:]), nil
	}
	i, err := strconv.Atoi(cstring(sh.Name[1:]))
	if err != nil {
		return "", err
	}
	return st.String(uint32(i))
}

// TODO(brainman): copy all IMAGE_REL_* consts from ldpe.go here

}

//sys	bind(name string, old string, flag int) (err error)

func Bind(name string, old string, flag int) (err error) {
	if fixwd(name, old) {
		defer runtime.UnlockOSThread()
	}
	return bind(name, old, flag)
}

//sys	mount(fd int, afd int, old string, flag int, aname string) (err error)

func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
	if fixwd(old) {

 * @see org.apache.maven.api.services.VersionParser#parseVersion(String)
 * @see org.apache.maven.api.Session#parseVersion(String)
 */
@Experimental
public interface Version extends Comparable<Version> {
    /**
     * Returns a string representation of this version.
     * @return the string representation of this version
     */
    @Nonnull
    String asString();