*/
public class FessLabels extends UserMessages {

    /** The serial version UID for object serialization. (Default) */
    private static final long serialVersionUID = 1L;

    /** The key of the message: Realm */
    public static final String LABELS_AUTH_REALM = "{labels.authRealm}";

    /** The key of the message: Status */
    public static final String LABELS_AVAILABLE = "{labels.available}";

	public final fun authParams ()Ljava/util/Map;
	public final fun charset ()Ljava/nio/charset/Charset;
	public fun equals (Ljava/lang/Object;)Z
	public fun hashCode ()I
	public final fun realm ()Ljava/lang/String;
	public final fun scheme ()Ljava/lang/String;
	public fun toString ()Ljava/lang/String;
	public final fun withCharset (Ljava/nio/charset/Charset;)Lokhttp3/Challenge;
}

There is no guarantee that the reference equality is preserved for standard Java, Groovy, and Kotlin types, or for Gradle-defined types.

Note that no reference equality is preserved between tasks: each task is its own "realm", so it is not possible to share objects between tasks.
Instead, you can use a <<build_services#build_services,build service>> to wrap the shared state.

[[config_cache:requirements:task_extensions]]

	println(f1())
	println(f2())
	println(f3())
}

func real1() {
	var f32 float32
	var f64 float64
	var c64 complex64
	var c128 complex128
	_ = real() // ERROR "not enough arguments"
	_ = real(1, 2) // ERROR "too many arguments"
	_ = real(10)
	_ = real(2.7182818)
	_ = real("foo" /* ERROR "expected complex" */)
	const _5 = real(1 + 2i)
	assert(_5 == 1)
	f32 = _5
	f64 = _5
	const _6 = real(0i)

                              std::is_convertible<T, std::string>::value>::type>
    Initializer(const T& v) {  // NOLINT(runtime/explicit)
      typedef typename RealType<T>::type RealT;
      Tensor t(DataTypeToEnum<RealT>::v(), TensorShape());
      t.flat<RealT>()(0) = RealT(v);
      tensor = t;
    }

    Initializer(const Tensor& t) : tensor(t) {}  // NOLINT(runtime/explicit)

        given:
        def real = candidates.createDir("installs/java/11.0.6.hs-adpt")
        def symlink = candidates.file("installs/java/symlink").createLink(real)

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(real, symlink)
        directories*.source.unique() == ["asdf-vm"]

        given:
        def real = candidates.createDir("java/11.0.6.hs-adpt")
        def symlink = candidates.file("java/symlink").createLink(real)

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(real, symlink)
        directories*.source.unique() == ["SDKMAN!"]

}

// readChannel returns wsstream.ReadChannel if real is true, or wsstream.IgnoreChannel.
func readChannel(real bool) wsstream.ChannelType {
	if real {
		return wsstream.ReadChannel
	}
	return wsstream.IgnoreChannel
}

// writeChannel returns wsstream.WriteChannel if real is true, or wsstream.IgnoreChannel.
func writeChannel(real bool) wsstream.ChannelType {
	if real {
		return wsstream.WriteChannel
	}

	// for compatibility shims. Consider:
	//
	//   //go:build go1.22
	//   type T struct { F std.Real } // correct new API
	//
	//   //go:build !go1.22
	//   type T struct { F fake } // shim
	//   type fake struct { ... }
	//   func (fake) M () {}
	//
	// These alternative declarations of T use either the std.Real
	// type, introduced in go1.22, or a fake type, for the field

            proxy_set_header Host $http_host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;