// license that can be found in the LICENSE file.

package maps

import "iter"

// All returns an iterator over key-value pairs from m.
// The iteration order is not specified and is not guaranteed
// to be the same from one call to the next.
func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V] {
	return func(yield func(K, V) bool) {
		for k, v := range m {
			if !yield(k, v) {
				return

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package iter provides basic definitions and operations
// related to iteration in Go.
package iter

import (
	"internal/race"
	"runtime"
	"unsafe"
)

// Seq is an iterator over sequences of individual values.

// license that can be found in the LICENSE file.

package slices

import (
	"cmp"
	"iter"
)

// All returns an iterator over index-value pairs in the slice.
// The indexes range in the usual order, from 0 through len(s)-1.
func All[Slice ~[]E, E any](s Slice) iter.Seq2[int, E] {
	return func(yield func(int, E) bool) {
		for i, v := range s {
			if !yield(i, v) {
				return
			}
		}

### Iterators

The new [iter] package provides the basic definitions for working with
user-defined iterators.

The [slices] package adds several functions that work with iterators:
- [All](/pkg/slices#All) returns an iterator over slice indexes and values.
- [Values](/pkg/slices#Values) returns an iterator over slice elements.
- [Backward](/pkg/slices#Backward) returns an iterator that loops over
  a slice backward.

	var wg sync.WaitGroup
	var iterChans [2]chan intIter
	wg.Add(2)
	iterChans[0] = make(chan intIter)
	iterChans[1] = make(chan intIter)
	go func() {
		defer wg.Done()

		iter := pullRange(100)
		iterChans[1] <- iter

		for i := range iterChans[0] {
			_, ok := i.next()
			if !ok {
				close(iterChans[1])
				break
			}
			iterChans[1] <- i
		}
	}()
	go func() {
		defer wg.Done()

        String version = model.getVersion();
        String modVersion = replaceCiFriendlyVersion(context, version);
        builder.version(modVersion);
    }

    //
    // Infer inner reactor dependencies version
    //
    void handleReactorDependencies(ModelTransformerContext context, Model model, Path pomFile, Model.Builder builder) {
        List<Dependency> newDeps = new ArrayList<>();

import java.io.IOException;

/**
 * Efficiently serializes hierarchical names, like Java class names or relative paths of resources.
 * Splits names into prefixes and suffixes along package separators, inner class separators, file separators and camel case borders.
 * Reuses these prefixes and suffixes to efficiently store names or parts of names it has seen before.
 *

#   $2: The full path of the output binary.
#   $3: Non-versioned name to use
function download_ztunnel_if_necessary () {
  if [[ -f "$2" ]]; then
    return
  fi
  # Enter the output directory.
  mkdir -p "$(dirname "$2")"
  pushd "$(dirname "$2")"

  # Download and make the binary executable
  echo "Downloading ztunnel: $1 to $2"

			name: "empty map at depth = 1",
			given: func() Mapper {
				// root (dest port)
				//   15001:
				//     inner (dest ip):
				//       <no matches>
				//       fallback: chain
				inner := NewDestinationIP()
				inner.OnNoMatch = ToChain("chain")

				root := NewDestinationPort()
				root.Map["15001"] = ToMatcher(inner.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// dest port
				// 15001: chain

    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Bar Bar
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
}

public class CodeFragment$run$Foo {
    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
    public method call(): void