MappedProperty map(String propertyName, Closure<?> value);

    MappedProperty map(String propertyName, Callable<?> value);

    /**
     * Mark a property as ineligible for convention mapping.
     */
    void ineligible(String propertyName);

    @Nullable
    <T> T getConventionValue(@Nullable T actualValue, String propertyName, boolean isExplicitValue);

    interface MappedProperty {

	// JobDeletionDurationSeconds tracks the time it took to delete the job since it
	// became eligible for deletion.
	JobDeletionDurationSeconds = metrics.NewHistogram(
		&metrics.HistogramOpts{
			Subsystem:      TTLAfterFinishedSubsystem,
			Name:           "job_deletion_duration_seconds",
			Help:           "The time it took to delete the job since it became eligible for deletion",
			StabilityLevel: metrics.ALPHA,

    @Override
    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

    /**
     * Is this variant eligible for caching?
     *
     * Only variants from a project component are eligible for caching.
     *
     * @see <a href="https://github.com/gradle/gradle/pull/23500#discussion_r1073224819">Context</a>
     */
    default boolean isEligibleForCaching() {

     */
    Property<JavaLanguageVersion> getLanguageVersion();

    /**
     * The vendor of the toolchain.
     * <p>
     * By default, toolchains from any vendor are eligible.
     * <p>
     * Note that the vendor can only be configured if the {@link #getLanguageVersion() language version} is configured as well.
     *
     * @since 6.8
     */
    Property<JvmVendorSpec> getVendor();

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Declares a rule eligible for caching.
 *
 * @since 4.9
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface CacheableRule {

		// add them to the eligible nodes
		nodeNames := util.GetLocalPersistentVolumeNodeNames(pv)
		if len(nodeNames) != 0 {
			// on the first found list of eligible nodes for the local PersistentVolume,
			// insert to the eligible node set.
			if eligibleNodes == nil {
				eligibleNodes = sets.New(nodeNames...)
			} else {
				// for subsequent finding of eligible nodes for the local PersistentVolume,

			continue
		}
		return false, proxierLastUpdated
	}
	return true, lastUpdated
}

// SyncNode syncs the node and determines if it is eligible or not. Eligible is
// defined as being: not tainted by ToBeDeletedTaint and not deleted.
func (hs *ProxierHealthServer) SyncNode(node *v1.Node) {
	hs.lock.Lock()
	defer hs.lock.Unlock()

	"istio.io/istio/pkg/config"
)

// IsEligibleForHealthStatusUpdates returns true if a given WorkloadEntry
// is allowed to receive health status updates sent by an Istio Proxy.
//
// Consider a workload eligible for health status updates as long as the
// WorkloadEntryHealthCheckAnnotation is present (no matter what the value is).
// In case the annotation is present but the value is not "true", the proxy should be allowed

    if (pooled2 != null) return pooled2

    return connect
  }

  /**
   * Returns the connection already attached to the call if it's eligible for a new exchange.
   *
   * If the call's connection exists and is eligible for another exchange, it is returned. If it
   * exists but cannot be used for another exchange, it is closed and this returns null.
   */

 */
@ServiceScope(Scope.Build.class)
public interface ResolvedVariantCache {
    /**
     * Caches resolved variants created by the given function if the identifier is eligible for caching.
     *
     * @param key key for the cache
     * @param mappingFunction function to create a {@link ResolvedVariant}
     * @return the resolved variant created by the function or a cached instance, if available