asDocMeta().id(id);
    }

    @Override
    public String[] getRoleNames() {
        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        return stream(getGroups()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    private String decode(final String value) {

func (f IteratorFunc[T]) Iterate(fn func(T) bool) {
	f(fn)
}

type Stream[T any] struct {
	it Iterator[T]
}

func (s Stream[T]) Iterate(fn func(T) bool) {
	if s.it == nil {
		return
	}
	s.it.Iterate(fn)
}

func FromIterator[T any](it Iterator[T]) Stream[T] {
	return Stream[T]{it: it}
}

func (s Stream[T]) DropWhile(fn func(T) bool) Stream[T] {
	return Pipe[T, T](s, func(t T) (T, bool) {
		return t, true
	})

			}
			if extracted {
				return keepFileErr{fmt.Errorf("next stream: %w", err)}
			}
			return fmt.Errorf("next stream: %w", err)
		}
		if stream.Name == "inspect.zip" {
			if extracted {
				return keepFileErr{errors.New("multiple inspect.zip streams found")}
			}
			_, err := io.Copy(w, stream)
			if err != nil {
				return fmt.Errorf("reading inspect stream: %w", err)
			}
			fmt.Println(okMsg)
			extracted = true

    public void insert(final User user) {
        chains().of(stream -> stream.forEach(c -> c.update(user)));
    }

    public boolean changePassword(final String username, final String password) {
        return chains().get(stream -> stream.allMatch(c -> c.changePassword(username, password)));
    }

    public void delete(final User user) {
        chains().of(stream -> stream.forEach(c -> c.delete(user)));
    }

    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {
    http2Connection.flush()
  }

  override fun finishRequest() {

 */

package org.gradle.internal.watch.registry.impl

import org.gradle.internal.file.FileHierarchySet
import org.gradle.internal.snapshot.TestSnapshotFixture
import spock.lang.Specification

import java.util.stream.Stream

import static org.gradle.internal.watch.registry.impl.AbstractFileWatcherUpdater.resolveWatchedFiles

class WatchedHierarchiesTest extends Specification implements TestSnapshotFixture {

package main

import (
	"fmt"
	"reflect"
)

type Stream[T any] struct {
}

func (s Stream[T]) DropWhile() Stream[T] {
	return Pipe[T, T](s)
}

func Pipe[T, R any](s Stream[T]) Stream[R] {
	it := func(fn func(R) bool) {
	}
	fmt.Println(reflect.TypeOf(it).String())
	return Stream[R]{}
}

func main() {
	s := Stream[int]{}
	s = s.DropWhile()

import org.gradle.internal.os.OperatingSystem;

import java.io.File;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class WindowsInstallationSupplier implements InstallationSupplier {

    private final WindowsRegistry windowsRegistry;
    private final OperatingSystem os;

//  done_event->Init();
//
//  XlaHostSendDeviceContext device_context(&stream, &gpu_dst,
//    shape, done_event);
//  device_context.CopyCPUTensorToDeviceSync(
//    &cpu_tensor, &device, &device_tensor);

class XlaHostSendDeviceContext : public DeviceContext {
 public:
  XlaHostSendDeviceContext(
      se::Stream* stream, se::DeviceMemoryBase* device_memory_base,

      if (file.isDirectory) {
        serveDirectory(stream, file.listFiles()!!)
      } else if (file.exists()) {
        serveFile(stream, file)
      } else {
        send404(stream, path)
      }
    } catch (e: IOException) {
      Platform.get().log("Failure serving Http2Stream: " + e.message, Platform.INFO, null)
    }
  }

  private fun send404(
    stream: Http2Stream,
    path: String,
  ) {