// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package http

// A mapping is a collection of key-value pairs where the keys are unique.
// A zero mapping is empty and ready to use.
// A mapping tries to pick a representation that makes [mapping.find] most efficient.
type mapping[K comparable, V any] struct {
	s []entry[K, V] // for few pairs
	m map[K]V       // for many pairs
}

{
  "dynamic_templates": [
    {
      "strings": {
        "mapping": {
          "type": "keyword"
        },
        "match": "*",
        "match_mapping_type": "string"
      }
    }
  ],
  "properties": {
    "settingsType": {
      "type": "keyword"
    },
    "fieldName": {
      "type": "keyword"
    },
    "readingAnalyzer": {
      "type": "keyword"
    },
    "readingTermAnalyzer": {

Shinsuke Sugaya <******@****.***> 1653046245 +0900

     * machine consumption, use the {@link #getSimpleNameToFullClassNamesMapping()} method, as it
     * provides a direct mapping from each simple name to the qualified name of the class to use.
     */
    String[] getImportPackages();

    /**
     * Returns a mapping from simple to qualified class name, derived from

	for _, p := range f.elf.Progs {
		if p.Type == elf.PT_LOAD && p.Flags&elf.PF_X != 0 {
			// The memory mapping that contains the segment
			// starts at an aligned address. Apparently this
			// is what pprof expects, as it uses this and the
			// start address of the mapping to compute PC
			// delta.
			return p.Vaddr - p.Vaddr%p.Align, nil
		}
	}
	return 0, fmt.Errorf("unknown load address")
}

//     Unfortunately, because Name is part of ObjectMeta, we can't store it as a NodeName at the API level.
//
//   - Hostname is the hostname of the local machine (from uname -n).
//     However, some components allow the user to pass in a --hostname-override flag,
//     which will override this in most places. In the absence of anything more meaningful,

//            }
        }
        baselineVersions
    }
...
```

## Perform the search

While doing the search no other activity should be done on the machine. Therefore, it
is best to have a dedicated machine running the search, e.g., using the CI infrastructure.

In order to check if the test passes for the current revision you can use [check-rev.sh](check-rev.sh).

        mapping.getVersionUsedBy(version("1.0-rc-3")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.0")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.1-milestone-1")).get() == CacheVersion.of(1)
        mapping.getVersionUsedBy(version("1.1-rc-1")).get() == CacheVersion.of(2)
        mapping.getVersionUsedBy(version("2.0")).get() == CacheVersion.of(2)

        ConstantToDependentsMapping mapping = merger.merge(newMapping, null, [] as Set)

        then:
        mapping.getConstantDependentsForClass("a").accessibleDependentClasses == ["1", "2"] as Set
        mapping.getConstantDependentsForClass("b").accessibleDependentClasses == ["3"] as Set
        mapping.getConstantDependentsForClass("c").accessibleDependentClasses == [] as Set

internal fun mergeAdjacentRanges(mappings: List<Mapping>): List<Mapping> {
  var index = 0
  val result = mutableListOf<Mapping>()

  while (index < mappings.size) {
    val mapping = mappings[index]
    val type = canonicalizeType(mapping.type)
    val mappedTo = mapping.mappedTo

    var unionWith: Mapping = mapping
    index++

    while (index < mappings.size) {