package javacompat

Import Path
	github.com/d2lang/elk-go/internal/javacompat (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 13 packages

Involved Source Files

	    gwt_priority_queue.go
	    gwt_stable_sort.go
	    identity.go
	    jsmath.go
	    numeric.go
	    ordered.go
	    priority_queue.go
	  d random.go
		Package javacompat contains the small parts of the Java runtime whose exact
		behavior is observable in ELK layouts.
Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type Comparator[T] (func)

		Type Parameters:
			T: any

		Comparator has the contract of java.util.Comparator.compare: negative when
		a is less than b, zero when they compare equal, and positive otherwise.

		As Inputs Of (at least 3)
			func NewGWTPriorityQueue[T](compare Comparator[T]) *GWTPriorityQueue[T]
			func NewPriorityQueue[T](compare Comparator[T]) *PriorityQueue[T]
			func NewPriorityQueueCapacity[T](capacity int, compare Comparator[T]) *PriorityQueue[T]

	 type GWTPriorityQueue[T] (struct)

		Type Parameters:
			T: any

		GWTPriorityQueue reproduces GWT 2.11.0's java.util.PriorityQueue
		implementation linked into elkjs 0.12.0. The relevant GWT source is
		unchanged from the 2.9.0 runtime used by the former elkjs 0.8.2 baseline.
		Its bulk-add heapification and equal-item sift-down behavior differ
		observably from OpenJDK's PriorityQueue.

		Methods (total 7)
			(*GWTPriorityQueue[T]) Add(item T)
			(*GWTPriorityQueue[T]) AddAll(items []T) bool
				AddAll appends the complete collection and then invokes GWT's recursive
				makeHeap routine. It does not repeatedly call Offer.

			(*GWTPriorityQueue[T]) IsEmpty() bool
			(*GWTPriorityQueue[T]) Len() int
			(*GWTPriorityQueue[T]) Offer(item T) bool
			(*GWTPriorityQueue[T]) Peek() (T, bool)
			(*GWTPriorityQueue[T]) Poll() (T, bool)
		As Outputs Of (at least one exported)
			func NewGWTPriorityQueue[T](compare Comparator[T]) *GWTPriorityQueue[T]

	 type IdentityMap[K, V] (struct)

		Type Parameters:
			K: comparable
			V: any

		IdentityMap provides IdentityHashMap equality semantics for identity-bearing
		comparable keys. K should be a pointer or an arena handle, never a value
		object whose == operation represents structural equality. Iteration is made
		deterministic in first-insertion order; ELK does not rely on the unspecified
		table order of java.util.IdentityHashMap.
		
		The zero value is ready to use.

		Methods (total 10)
			(*IdentityMap[K, V]) Clear()
			(*IdentityMap[K, V]) ContainsKey(key K) bool
			(*IdentityMap[K, V]) Get(key K) (V, bool)
			(*IdentityMap[K, V]) IsEmpty() bool
			(*IdentityMap[K, V]) Keys() []K
			(*IdentityMap[K, V]) Len() int
			(*IdentityMap[K, V]) Put(key K, value V) (V, bool)
			(*IdentityMap[K, V]) Range(visit func(K, V) bool)
			(*IdentityMap[K, V]) Remove(key K) (V, bool)
			(*IdentityMap[K, V]) Values() []V
		As Outputs Of (at least one exported)
			func NewIdentityMap[K, V]() *IdentityMap[K, V]

	 type IdentitySet[K] (struct)

		Type Parameters:
			K: comparable

		IdentitySet is IdentityMap's set counterpart. K should be a pointer or an
		arena handle so Go equality is object identity.

		Methods (total 8)
			(*IdentitySet[K]) Add(value K) bool
			(*IdentitySet[K]) Clear()
			(*IdentitySet[K]) Contains(value K) bool
			(*IdentitySet[K]) IsEmpty() bool
			(*IdentitySet[K]) Len() int
			(*IdentitySet[K]) Range(visit func(K) bool)
			(*IdentitySet[K]) Remove(value K) bool
			(*IdentitySet[K]) Values() []K
		As Outputs Of (at least one exported)
			func NewIdentitySet[K]() *IdentitySet[K]

	 type OrderedMap[K, V] (struct)

		Type Parameters:
			K: comparable
			V: any

		OrderedMap is an insertion-ordered map matching LinkedHashMap's default
		(accessOrder=false) behavior. Replacing a value does not move its key;
		removing and reinserting a key appends it at the end.
		
		The zero value is ready to use.

		Methods (total 13)
			(*OrderedMap[K, V]) Clear()
				Clear removes all entries.

			(*OrderedMap[K, V]) ContainsKey(key K) bool
				ContainsKey reports whether key is present.

			(*OrderedMap[K, V]) First() (K, V, bool)
				First returns the oldest entry.

			(*OrderedMap[K, V]) Get(key K) (V, bool)
				Get looks up a value.

			(*OrderedMap[K, V]) IsEmpty() bool
				IsEmpty reports whether the map has no entries.

			(*OrderedMap[K, V]) Keys() []K
				Keys returns keys in insertion order.

			(*OrderedMap[K, V]) Last() (K, V, bool)
				Last returns the newest entry.

			(*OrderedMap[K, V]) Len() int
				Len returns the number of entries.

			(*OrderedMap[K, V]) Put(key K, value V) (V, bool)
				Put inserts or replaces a value. It returns the old value and whether the
				key was already present.

			(*OrderedMap[K, V]) PutIfAbsent(key K, value V) (V, bool)
				PutIfAbsent inserts only when key is absent and returns the existing or new
				value plus whether an existing entry was found.

			(*OrderedMap[K, V]) Range(visit func(K, V) bool)
				Range visits entries in insertion order until visit returns false.
				Structural mutation during Range is unsupported, matching Java iterator
				fail-fast semantics without exposing a concurrent-modification exception.

			(*OrderedMap[K, V]) Remove(key K) (V, bool)
				Remove deletes key, preserving the relative order of all remaining keys.

			(*OrderedMap[K, V]) Values() []V
				Values returns values in key insertion order.

		As Outputs Of (at least one exported)
			func NewOrderedMap[K, V]() *OrderedMap[K, V]

	 type OrderedSet[T] (struct)

		Type Parameters:
			T: comparable

		OrderedSet is an insertion-ordered set matching LinkedHashSet.
		The zero value is ready to use.

		Methods (total 8)
			(*OrderedSet[T]) Add(value T) bool
				Add inserts value and reports whether the set changed.

			(*OrderedSet[T]) Clear()
				Clear removes every value.

			(*OrderedSet[T]) Contains(value T) bool
				Contains reports whether value is present.

			(*OrderedSet[T]) IsEmpty() bool
				IsEmpty reports whether the set is empty.

			(*OrderedSet[T]) Len() int
				Len returns the number of values.

			(*OrderedSet[T]) Range(visit func(T) bool)
				Range visits values in insertion order until visit returns false.

			(*OrderedSet[T]) Remove(value T) bool
				Remove deletes value and reports whether the set changed.

			(*OrderedSet[T]) Values() []T
				Values returns values in insertion order.

		As Outputs Of (at least one exported)
			func NewOrderedSet[T]() *OrderedSet[T]

	 type PriorityQueue[T] (struct)

		Type Parameters:
			T: any

		PriorityQueue is a clean-room binary min-heap whose tie behavior is pinned by
		elkjs oracle vectors. Java does not define FIFO ordering for equal elements,
		but ELK observes the heap-array order, so left-child and strict-comparison
		choices are part of this compatibility type's tested behavior.

		Methods (total 9)
			(*PriorityQueue[T]) Add(item T)
				Add inserts item. Java's add and offer have identical heap behavior.

			(*PriorityQueue[T]) Clear()
				Clear removes every element while releasing references held by the backing
				slice.

			(*PriorityQueue[T]) Elements() []T
				Elements returns a copy in PriorityQueue iterator order (the heap-array
				order). This order is deliberately not sorted, just like Java's iterator.

			(*PriorityQueue[T]) IsEmpty() bool
				IsEmpty reports whether the queue is empty.

			(*PriorityQueue[T]) Len() int
				Len returns the number of queued elements.

			(*PriorityQueue[T]) Offer(item T) bool
				Offer inserts item and returns true, matching PriorityQueue.offer.

			(*PriorityQueue[T]) Peek() (T, bool)
				Peek returns the least element without removing it.

			(*PriorityQueue[T]) Poll() (T, bool)
				Poll removes and returns the least element.

			(*PriorityQueue[T]) RemoveFirst(match func(T) bool) bool
				RemoveFirst removes the first element in the queue's internal array for
				which match returns true. This is PriorityQueue.remove(Object) with equality
				supplied explicitly, which also supports non-comparable Go values.

		As Outputs Of (at least 2)
			func NewPriorityQueue[T](compare Comparator[T]) *PriorityQueue[T]
			func NewPriorityQueueCapacity[T](capacity int, compare Comparator[T]) *PriorityQueue[T]

	 type Random (struct)
		Random is a bit-for-bit implementation of java.util.Random from Java 8.
		
		Random is not safe for concurrent use. ELK owns one instance per layout, as
		the Java implementation does, so synchronization would only obscure the
		order in which random values are consumed.

		Methods (total 9)
			(*Random) NextBoolean() bool
				NextBoolean implements Random.nextBoolean().

			(*Random) NextBytes(dst []byte)
				NextBytes implements Random.nextBytes(byte[]). Java's byte is signed, but
				assigning its low eight bits to a Go byte gives the same byte sequence.

			(*Random) NextDouble() float64
				NextDouble implements Random.nextDouble().

			(*Random) NextFloat() float32
				NextFloat implements Random.nextFloat().

			(*Random) NextGaussian() float64
				NextGaussian implements Random.nextGaussian(), including its cached second
				sample. ELK 0.8.1 does not use this in a layout path, but providing the Java
				behavior prevents consumers from accidentally substituting math/rand.
				Math-library results may differ by a final bit across platforms, just as
				Java's Math implementation may, while the random-value consumption is exact.

			(*Random) NextInt() int32
				NextInt implements Random.nextInt().

			(*Random) NextIntN(bound int32) int32
				NextIntN implements Random.nextInt(bound). It panics for a non-positive
				bound, corresponding to Java's IllegalArgumentException.

			(*Random) NextLong() int64
				NextLong implements Random.nextLong(). The low 32 bits are sign-extended
				before addition, as required by Java's two signed int32 draws.

			(*Random) SetSeed(seed int64)
				SetSeed implements Random.setSeed(long). It also clears the cached value
				used by NextGaussian.

		As Outputs Of (at least one exported)
			func NewRandom(seed int64) *Random
		As Inputs Of (at least 4)
			func github.com/d2lang/elk-go/internal/layered/p3order.NewBarycenterHeuristic(arena *layered.LGraphArena, resolver *p3order.ForsterConstraintResolver, random *Random, distributor *p3order.BarycenterPortDistributor) *p3order.BarycenterHeuristic
			func github.com/d2lang/elk-go/internal/layered/p3order.NewGraphInfoHolder(arena *layered.LGraphArena, graphID layered.LGraphID, crossMinType p3order.CrossMinType, graphs []*p3order.GraphInfoHolder, random *Random) (*p3order.GraphInfoHolder, error)
			func github.com/d2lang/elk-go/internal/layered/p5edges/orthogonal.BreakNonCriticalCycles(segments []*orthogonal.HyperEdgeSegment, random *Random)
			func github.com/d2lang/elk-go/internal/layered/p5edges/orthogonal.DetectCycles(segments []*orthogonal.HyperEdgeSegment, criticalOnly bool, random *Random) []*orthogonal.HyperEdgeSegmentDependency


Package-Level Functions (total 34)

	 func BooleanHashCode(value bool) int32
		BooleanHashCode implements Boolean.hashCode(boolean).

	 func DoubleCompare(a, b float64) int
		DoubleCompare implements Double.compare. In particular, -0.0 sorts before
		+0.0 and every NaN sorts after positive infinity and compares equal to every
		other NaN.

	 func DoubleHashCode(value float64) int32
		DoubleHashCode implements Double.hashCode(double).

	 func DoubleToInt(value float64) int32
		DoubleToInt and DoubleToLong implement Java's narrowing primitive casts:
		NaN becomes zero, finite out-of-range values and infinities saturate, and
		finite in-range values truncate toward zero.

	 func DoubleToLong(value float64) int64
	 func DoubleToLongBits(value float64) uint64
		DoubleToLongBits implements Double.doubleToLongBits, including NaN
		canonicalization. Use math.Float64bits when Java's doubleToRawLongBits is
		specifically required.

	 func FloatCompare(a, b float32) int
		FloatCompare implements Float.compare.

	 func FloatHashCode(value float32) int32
		FloatHashCode implements Float.hashCode(float).

	 func FloatToIntBits(value float32) uint32
		FloatToIntBits implements Float.floatToIntBits, including NaN
		canonicalization.

	 func GWTStableSort[T](values []T, compare func(T, T) int)

		Type Parameters:
			T: any

		GWTStableSort reproduces the object-array legacy merge sort in GWT 2.11.0's
		emulated java.util.Arrays. The relevant implementation is unchanged from
		GWT 2.9.0. Comparator invocation order is observable when a comparator
		records comparisons or derives transitive state, as ELK's model-order
		comparators do.

	 func HashMapSpread(hash int32) int32
		HashMapSpread reproduces the one-step high-bit spread observed by ELK's
		Java-compatible hash tables. Its behavior is pinned by independent vectors.

	 func IntCompare(a, b int32) int
		IntCompare and LongCompare implement Integer.compare and Long.compare.

	 func IntToByte(value int32) int8
		Narrowing integral conversions implement Java casts.

	 func IntToChar(value int32) uint16
	 func IntToShort(value int32) int16
	 func JSMathCos(x float64) float64
	 func JSMathSin(x float64) float64
		JSMathSin and JSMathCos reproduce the fdlibm implementation used by V8's
		Math.sin and Math.cos for the medium-size arguments emitted by ELK Radial.
		The kernels and constants are adapted from Node.js v24.19.0's pinned V8
		deps/v8/src/base/ieee754.cc (itself adapted from fdlibm). Very large
		arguments fall back to Go's math package; layout angles are many orders of
		magnitude below that boundary.

	 func LongCompare(a, b int64) int
	 func LongHashCode(value int64) int32
		LongHashCode implements Long.hashCode(long).

	 func MathMaxDouble(a, b float64) float64
	 func MathMinDouble(a, b float64) float64
		MathMinDouble and MathMaxDouble preserve Java's NaN and signed-zero rules.

	 func MathRoundDouble(value float64) int64
		MathRoundDouble and MathRoundFloat implement Math.round.

	 func MathRoundFloat(value float32) int32
	 func NewGWTPriorityQueue[T](compare Comparator[T]) *GWTPriorityQueue[T]

		Type Parameters:
			T: any

	 func NewIdentityMap[K, V]() *IdentityMap[K, V]

		Type Parameters:
			K: comparable
			V: any

	 func NewIdentitySet[K]() *IdentitySet[K]

		Type Parameters:
			K: comparable

	 func NewOrderedMap[K, V]() *OrderedMap[K, V]

		Type Parameters:
			K: comparable
			V: any

		NewOrderedMap constructs an empty insertion-ordered map.

	 func NewOrderedSet[T]() *OrderedSet[T]

		Type Parameters:
			T: comparable

		NewOrderedSet constructs an empty insertion-ordered set.

	 func NewPriorityQueue[T](compare Comparator[T]) *PriorityQueue[T]

		Type Parameters:
			T: any

		NewPriorityQueue returns an empty Java-compatible min-priority queue.

	 func NewPriorityQueueCapacity[T](capacity int, compare Comparator[T]) *PriorityQueue[T]

		Type Parameters:
			T: any

		NewPriorityQueueCapacity is NewPriorityQueue with a capacity hint. Java's
		growth policy does not affect heap order, but avoiding reallocations is handy
		for the larger layered-layout queues.

	 func NewRandom(seed int64) *Random
		NewRandom constructs a Java-compatible pseudo-random number generator.

	 func StringHashCode(value string) int32
		StringHashCode implements String.hashCode over Java UTF-16 code units, not
		Unicode code points. This distinction matters for supplementary characters.

	 func UnsignedRightShiftInt(value int32, distance uint) int32
		UnsignedRightShiftInt and UnsignedRightShiftLong implement Java's >>>. Java
		masks the shift distance to five or six bits respectively.

	 func UnsignedRightShiftLong(value int64, distance uint) int64

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.