import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty

/**
 * Lazy value that guaranties safe publication and checks validity on every access
 */
@JvmInline
internal value class ValidityAwareCachedValue<T>(
    private val lazyValue: Lazy<T>,
) : ReadOnlyProperty<KaLifetimeOwner, T> {
    override fun getValue(thisRef: KaLifetimeOwner, property: KProperty<*>): T {

    private val lazyValue = lazy(LazyThreadSafetyMode.PUBLICATION, init)

    override fun getValue(thisRef: Any, property: KProperty<*>): T {
        token.assertIsValidAndAccessible()
        return lazyValue.value
    }
}

            )
    }


/**
 * Delegated property getter that locates extensions.
 */
inline operator fun <reified T : Any> ExtensionContainer.getValue(thisRef: Any?, property: KProperty<*>): T =
    getByName<T>(property.name)


/**
 * Adds a new extension to this container.
 *
 * @param T the public type of the added extension

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's
     * getter method (and can declare additional child properties).
     *

                        (methodShouldNotBeAnnotatedMessage {type('com.moowork.gradle.node.npm.NpmSetupTask').kind('setter').method('setArgs').annotation('Internal').includeLink()}): ERROR,
                        (missingAnnotationMessage { type('com.moowork.gradle.node.yarn.YarnSetupTask').property('args').missingInputOrOutput().includeLink() }): ERROR,

fun x() {
    val xProperty = 10
    fun xFunction() = 11
    typealias xTypealias = 10
    class XClass<XT> {}
    enum class XEnum {
        X_ENUM_ENTRY;

        fun xEnumMember(){}
    }

    class Y <YT> {
        val yProperty = 10
        fun yFunction() = 11
        typealias yTypealias = 10
        class YClass<YTT> {}
        enum class YEnum {
            Y_ENUM_ENTRY;

            fun yEnumMember(){}

     * </p>
     * <p>
     * Values are not allowed to be null.
     * </p>
     *
     * @param name Name of the property
     * @param value Value of the property
     * @since 3.4
     */
    public void property(final String name, final Object value) {
        checkForNullValue(name, value);
        if (DeferredUtil.isDeferred(value)) {

/**
 * An implementation of a Groovy MetaClass that is instrumented and might need to cancel some optimizations
 * in order to get the instrumentation to work properly.
 */
public interface InstrumentedMetaClass {
    /**
     * Checks if accessing a property by the specified name would be intercepted by the instrumentation at this
     * specific moment. The implementation may return different values at different times.
     */

     */
    @Nonnull
    Map<String, String> getProperties(@Nonnull Project project);

    /**
     * Set a given project property.
     *
     * @param project the project to modify
     * @param key they property's key
     * @param value the value or {@code null} to unset the property
     */
    void setProperty(@Nonnull Project project, @Nonnull String key, @Nullable String value);

    @Nonnull

		<property name="queueIndex">"fess_crawler.queue"</property>
		<property name="queueShards">5</property>
		<property name="queueReplicas">1</property>
		<property name="dataIndex">"fess_crawler.data"</property>
		<property name="dataShards">5</property>
		<property name="dataReplicas">1</property>
		<property name="filterIndex">"fess_crawler.filter"</property>
		<property name="filterShards">5</property>