<w>jdks</w>
      <w>jsshell</w>
      <w>proguarded</w>
      <w>protobuf</w>
      <w>redirector</w>
      <w>remapper</w>
      <w>sonatype</w>
      <w>streamex</w>
      <w>unpresent</w>
    </words>
  </dictionary>

    return new Present<>(
        checkNotNull(
            function.apply(reference),
            "the Function passed to Optional.transform() must not return null."));
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object instanceof Present) {
      Present<?> other = (Present<?>) object;
      return reference.equals(other.reference);
    }

    return new Present<>(
        checkNotNull(
            function.apply(reference),
            "the Function passed to Optional.transform() must not return null."));
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object instanceof Present) {
      Present<?> other = (Present<?>) object;
      return reference.equals(other.reference);
    }

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 47341
releaseNotes:
- |

    public T get() {
        return delegate.get();
    }

    public boolean isPresent() {
        return delegate.isPresent();
    }

    public boolean isEmpty() {
        return !delegate.isPresent();
    }

    public void ifPresent(Consumer<? super T> action) {
        delegate.ifPresent(action);
    }

    @SuppressWarnings("unused")

			os.Setenv(k, v)
		}

		ok, err := IsPresent()
		if err != nil && !test.ShouldFail {
			t.Fatalf("Test %d: %v", i, err)
		}
		if err == nil && test.ShouldFail {
			t.Fatalf("Test %d: should have failed but succeeded", i)
		}

		if !test.ShouldFail && ok != test.IsPresent {
			t.Fatalf("Test %d: reported that KMS present=%v - want present=%v", i, ok, test.IsPresent)
		}
	}
}

var isPresentTests = []struct {

        provider2.get() == ["a", "b"]
    }

    def "isPresent is true if all sources are present"() {
        given:
        def provider1 = new MergeProvider([providers.provider { new Object() }])
        def provider2 = new MergeProvider([providers.provider { new Object() }, providers.provider { new Object() }])

        expect:
        provider1.isPresent()
        provider2.isPresent()
    }

        }
    };

    /**
     * Checks if this attribute value is present, defined as not {@code null} and not {@link AttributeValue#MISSING}
     *
     * @return {@code true} if value is present, {@code false} otherwise
     */
    boolean isPresent();

    /**
     * Returns the value of this attribute.

                .map(OriginatingElement::getElement);

            if (!maybeOriginatingElement.isPresent()) {
                return false;
            }

            ExecutableElement originatingElement = maybeOriginatingElement.get();
            return AnnotationUtils.findMetaAnnotationMirror(originatingElement, annotationType).isPresent();
        };
    }

            .map(Object::toString)
            .map(DefaultPluginId::new);

        StringBuilder builder = new StringBuilder();
        boolean typeRelevant = rootType.isPresent() && !typeIrrelevantInErrorMessage;
        if (typeRelevant) {
            if (pluginId.isPresent()) {
                builder.append("In plugin '")
                    .append(pluginId.get())
                    .append("' type '");
            } else {