}
	a.waypoints = waypointsCollection{
		Collection: Waypoints,
	}
	a.authorizationPolicies = AllPolicies

	return a
}

// Lookup finds all addresses associated with a given key. Many different key formats are supported; see inline comments.
func (a *index) Lookup(key string) []model.AddressInfo {
	// 1. Workload UID
	if w := a.workloads.GetKey(krt.Key[model.WorkloadInfo](key)); w != nil {

	register(global, local, globalName)
	local.Lookup(normalize(globalName)).Deprecated = deprecated
}

// addCredentialProviderFlags adds flags from k8s.io/kubernetes/pkg/credentialprovider
func addCredentialProviderFlags(fs *pflag.FlagSet) {
	// lookup flags in global flag set and re-register the values with our flagset
	local := pflag.NewFlagSet(os.Args[0], pflag.ExitOnError)

func (kvs KVS) LookupKV(key string) (KV, bool) {
	for _, kv := range kvs {
		if kv.Key == key {
			return kv, true
		}
	}
	return KV{}, false
}

// Lookup - lookup a key in a list of KVS
func (kvs KVS) Lookup(key string) (string, bool) {
	for _, kv := range kvs {
		if kv.Key == key {
			return kv.Value, true
		}
	}
	return "", false
}

// Config - MinIO server config structure.

        "lookup" and "output".
    """
    with session.Session(graph=ops.Graph()) as sess:
      input_vocabs_placeholder, lookup_tensor, output_tensor = (
          self._create_vocab_table_lookup_model_tf1(sess)
      )

      inputs = {'input_vocabs': input_vocabs_placeholder}
      outputs = {
          'lookup': lookup_tensor,
          'output': output_tensor,
      }

            assert v.cachedAt == 123
            assert v.descriptorHash == TestHashCodes.hashCodeFrom(10)
            assert v.cachedFile == testFile
        }
    }

    def "lookup key must not be null"() {
        when:
        index.lookup(null)

        then:
        def e = thrown(IllegalArgumentException)
        e.message == "key cannot be null"
    }

  }
  name    = item.name
  context = "./samples/bookinfo/src/${item.source}"
  tags    = [
    for x in setproduct([HUB], "${split(",", TAGS)}") : join("/${item.name}:", x)
  ]
  args = lookup(item, "args", {})
  platforms = split(",",lookup(item, "platforms", PLATFORMS))

import org.apache.maven.api.annotations.Nonnull;

public interface ExtensibleEnumRegistry<T extends ExtensibleEnum> extends Service {
    @Nonnull
    Optional<T> lookup(@Nonnull String id);

    @Nonnull
    default T require(@Nonnull String id) {
        return lookup(id).orElseThrow(() -> new IllegalArgumentException("Unknown extensible enum value '" + id + "'"));
    }

				goos: "openbsd",
			},
			resolv: &dnsConfig{lookup: []string{"bind", "file"}},
			hostTests: []nssHostTest{
				{"google.com", "myhostname", hostLookupDNSFiles},
				{"foo.local", "myhostname", hostLookupDNSFiles},
			},
		},
		{
			name: "openbsd_lookup_file_bind",
			c: &conf{
				goos: "openbsd",
			},
			resolv:    &dnsConfig{lookup: []string{"file", "bind"}},

	types.Typ[types.Float64],
	types.Typ[types.Complex64],
	types.Typ[types.Complex128],
	types.Typ[types.String],

	// basic type aliases
	types.Universe.Lookup("byte").Type(),
	types.Universe.Lookup("rune").Type(),

	// error
	types.Universe.Lookup("error").Type(),

	// untyped types
	types.Typ[types.UntypedBool],
	types.Typ[types.UntypedInt],
	types.Typ[types.UntypedRune],
	types.Typ[types.UntypedFloat],

    @Test
    void testEnsureResolverSessionHasMavenWorkspaceReader() throws Exception {
        WsrClassCatcher wsrClassCatcher =
                (WsrClassCatcher) getContainer().lookup(AbstractMavenLifecycleParticipant.class, "WsrClassCatcher");
        Maven maven = getContainer().lookup(Maven.class);
        MavenExecutionRequest request =
                createMavenExecutionRequest(getProject("simple")).setGoals(asList("validate"));