}

    override val getter: KaPropertyGetterSymbol?
        get() = withValidityAssertion {
            if (descriptor.isDynamic()) return null
            val getter = descriptor.getter ?: return KaFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KaFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

		pc.Kubernetes.WarnAfter = jwt.NewNumericDate(now.Add(time.Duration(warnafter) * time.Second))
	}

	return sc, pc, nil
}

func NewValidator(getter ServiceAccountTokenGetter) Validator {
	return &validator{
		getter: getter,
	}
}

type validator struct {
	getter ServiceAccountTokenGetter
}

var _ = Validator(&validator{})

    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
        val getter = findKotlinProperty(receiverClass, name)?.let(::kotlinPropertyGetter)
            ?: findKotlinFunctionGetter(receiverClass, name)
            ?: findJavaGetter(receiverClass, name)

        return getter?.let(::ResolvedRead) ?: UnresolvedRead
    }

     * <ul>
     *     <li>It must be an interface.</li>
     *     <li>It must contain only getter-like and setter-like methods.</li>
     *     <li>There must be one getter corresponding to exactly one setter, with matching value types.</li>
     * </ul>
     * <p>
     * For each getter-like method:
     * <ul>
     *     <li>The name must start with {@code "get"} or {@code "is"}, followed by an uppercase letter.</li>

            Logger.error("Failed to create suggest index. ", e);
            return internalServerError();
        }
    }



    public static Result createContent() {
        ContentsCreator getter = new ContentsCreator();
        getter.create();
        return ok("Finished to create content index;");
    }

 * resolution to discriminate between various binaries that may match the requirements (such
 * as a platform, a build type, ...).
 *
 * This annotation must be set on a getter. The return type of the getter must either be
 * a {@link String} or a class implementing {@link org.gradle.api.Named}.
 *
 * @since 2.6
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating

        if (mostSpecificDeclaration.getReturnType()==Boolean.TYPE) {
            getters = new ArrayList<>();
            for (Method getter : declaringMethods) {
                if (Proxy.isProxyClass(getter.getDeclaringClass())) {
                    continue;
                }
                getters.add(getter);
            }
        } else {
            getters = Collections.singletonList(mostSpecificDeclaration);
        }

You can declare a read-only managed nested property by adding an abstract getter method for the property to a type annotated with link:{javadocPath}/org/gradle/api/tasks/Nested.html[`@Nested`].
The property should not have any setter methods.
Gradle provides the implementation for the getter method and creates a value for the property.

            Method getter = JavaPropertyReflectionUtil.findGetterMethod(sourceType, propertyName);
            if (getter != null && SupportsConvention.class.isAssignableFrom(getter.getReturnType())) {
                SupportsConvention target;
                try {
                    target = Cast.uncheckedNonnullCast(getter.invoke(_source));

                throwParameterValidationError(clazz, String.format("A setter for property %s was found but no getter.", property));
            } else if (!setters.get(property).equals(getters.get(property))) {
                throwParameterValidationError(clazz, String.format("Setter and getter for property %s have non corresponding types.", property));
            }
        }
    }