diff --git a/collection/collection-ktx/api/1.5.0-beta01.txt b/collection/collection-ktx/api/1.5.0-beta01.txt new file mode 100644 index 0000000000000..e6f50d0d0fd11 --- /dev/null +++ b/collection/collection-ktx/api/1.5.0-beta01.txt @@ -0,0 +1 @@ +// Signature format: 4.0 diff --git a/collection/collection-ktx/api/restricted_1.5.0-beta01.txt b/collection/collection-ktx/api/restricted_1.5.0-beta01.txt new file mode 100644 index 0000000000000..e6f50d0d0fd11 --- /dev/null +++ b/collection/collection-ktx/api/restricted_1.5.0-beta01.txt @@ -0,0 +1 @@ +// Signature format: 4.0 diff --git a/collection/collection/api/1.5.0-beta01.txt b/collection/collection/api/1.5.0-beta01.txt new file mode 100644 index 0000000000000..1594610661c21 --- /dev/null +++ b/collection/collection/api/1.5.0-beta01.txt @@ -0,0 +1,2394 @@ +// Signature format: 4.0 +package androidx.collection { + + public class ArrayMap extends androidx.collection.SimpleArrayMap implements java.util.Map { + ctor public ArrayMap(); + ctor public ArrayMap(androidx.collection.SimpleArrayMap?); + ctor public ArrayMap(int); + method public boolean containsAll(java.util.Collection); + method public boolean containsKey(Object?); + method public boolean containsValue(Object?); + method public java.util.Set!> entrySet(); + method public V! get(Object?); + method public java.util.Set keySet(); + method public void putAll(java.util.Map); + method public V! remove(Object?); + method public boolean removeAll(java.util.Collection); + method public boolean retainAll(java.util.Collection); + method public java.util.Collection values(); + } + + public final class ArrayMapKt { + method public static inline androidx.collection.ArrayMap arrayMapOf(); + method public static androidx.collection.ArrayMap arrayMapOf(kotlin.Pair... pairs); + } + + public final class ArraySet implements java.util.Collection kotlin.jvm.internal.markers.KMutableCollection kotlin.jvm.internal.markers.KMutableSet java.util.Set { + ctor public ArraySet(); + ctor public ArraySet(androidx.collection.ArraySet? set); + ctor public ArraySet(E[]? array); + ctor public ArraySet(optional int capacity); + ctor public ArraySet(java.util.Collection? set); + method public boolean add(E element); + method public void addAll(androidx.collection.ArraySet array); + method public boolean addAll(java.util.Collection elements); + method public void clear(); + method public operator boolean contains(E element); + method public boolean containsAll(java.util.Collection elements); + method public void ensureCapacity(int minimumCapacity); + method public int getSize(); + method public int indexOf(Object? key); + method public boolean isEmpty(); + method public java.util.Iterator iterator(); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ArraySet array); + method public boolean removeAll(java.util.Collection elements); + method public E removeAt(int index); + method public boolean retainAll(java.util.Collection elements); + method public Object?[] toArray(); + method public T[] toArray(T[] array); + method public E valueAt(int index); + property public int size; + } + + public final class ArraySetKt { + method public static inline androidx.collection.ArraySet arraySetOf(); + method public static androidx.collection.ArraySet arraySetOf(T... values); + } + + public final class CircularArray { + ctor public CircularArray(); + ctor public CircularArray(optional int minCapacity); + method public void addFirst(E element); + method public void addLast(E element); + method public void clear(); + method public operator E get(int index); + method public E getFirst(); + method public E getLast(); + method public boolean isEmpty(); + method public E popFirst(); + method public E popLast(); + method public void removeFromEnd(int count); + method public void removeFromStart(int count); + method public int size(); + property public final E first; + property public final E last; + } + + public final class CircularIntArray { + ctor public CircularIntArray(); + ctor public CircularIntArray(optional int minCapacity); + method public void addFirst(int element); + method public void addLast(int element); + method public void clear(); + method public operator int get(int index); + method public int getFirst(); + method public int getLast(); + method public boolean isEmpty(); + method public int popFirst(); + method public int popLast(); + method public void removeFromEnd(int count); + method public void removeFromStart(int count); + method public int size(); + property public final int first; + property public final int last; + } + + public abstract sealed class DoubleList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(double element); + method public final boolean containsAll(androidx.collection.DoubleList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final double elementAt(@IntRange(from=0L) int index); + method public final inline double elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final double first(); + method public final inline double first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator double get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(double element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final double last(); + method public final inline double last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(double element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + } + + public final class DoubleListKt { + method public static inline androidx.collection.DoubleList buildDoubleList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.DoubleList buildDoubleList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.DoubleList doubleListOf(); + method public static androidx.collection.DoubleList doubleListOf(double element1); + method public static androidx.collection.DoubleList doubleListOf(double element1, double element2); + method public static androidx.collection.DoubleList doubleListOf(double element1, double element2, double element3); + method public static androidx.collection.DoubleList doubleListOf(double... elements); + method public static androidx.collection.DoubleList emptyDoubleList(); + method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2, double element3); + method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(double... elements); + } + + public abstract sealed class FloatFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(float key); + method public final int getCapacity(); + method public final float getOrDefault(float key, float defaultValue); + method public final inline float getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class FloatFloatMapKt { + method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatFloatMap emptyFloatFloatMap(); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5); + } + + @kotlin.jvm.JvmInline public final value class FloatFloatPair { + ctor public FloatFloatPair(float first, float second); + method public inline operator float component1(); + method public inline operator float component2(); + property public final inline float first; + property public final long packedValue; + property public final inline float second; + field public final long packedValue; + } + + public abstract sealed class FloatIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(float key); + method public final int getCapacity(); + method public final int getOrDefault(float key, int defaultValue); + method public final inline int getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class FloatIntMapKt { + method public static inline androidx.collection.FloatIntMap buildFloatIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatIntMap buildFloatIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatIntMap emptyFloatIntMap(); + method public static androidx.collection.FloatIntMap floatIntMapOf(); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5); + } + + public abstract sealed class FloatList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(float element); + method public final boolean containsAll(androidx.collection.FloatList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final float elementAt(@IntRange(from=0L) int index); + method public final inline float elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final float first(); + method public final inline float first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator float get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(float element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final float last(); + method public final inline float last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(float element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + } + + public final class FloatListKt { + method public static inline androidx.collection.FloatList buildFloatList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatList buildFloatList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatList emptyFloatList(); + method public static androidx.collection.FloatList floatListOf(); + method public static androidx.collection.FloatList floatListOf(float element1); + method public static androidx.collection.FloatList floatListOf(float element1, float element2); + method public static androidx.collection.FloatList floatListOf(float element1, float element2, float element3); + method public static androidx.collection.FloatList floatListOf(float... elements); + method public static inline androidx.collection.MutableFloatList mutableFloatListOf(); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2, float element3); + method public static inline androidx.collection.MutableFloatList mutableFloatListOf(float... elements); + } + + public abstract sealed class FloatLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(float key); + method public final int getCapacity(); + method public final long getOrDefault(float key, long defaultValue); + method public final inline long getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class FloatLongMapKt { + method public static inline androidx.collection.FloatLongMap buildFloatLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatLongMap buildFloatLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatLongMap emptyFloatLongMap(); + method public static androidx.collection.FloatLongMap floatLongMapOf(); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5); + } + + public abstract sealed class FloatObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(float key); + method public final int getCapacity(); + method public final V getOrDefault(float key, V defaultValue); + method public final inline V getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class FloatObjectMapKt { + method public static inline androidx.collection.FloatObjectMap buildFloatObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.FloatObjectMap buildFloatObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.FloatObjectMap emptyFloatObjectMap(); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5); + } + + public abstract sealed class FloatSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(float element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline float first(); + method public final inline float first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @IntRange(from=0L) public final int size; + } + + public final class FloatSetKt { + method public static inline androidx.collection.FloatSet buildFloatSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatSet buildFloatSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatSet emptyFloatSet(); + method public static androidx.collection.FloatSet floatSetOf(); + method public static androidx.collection.FloatSet floatSetOf(float element1); + method public static androidx.collection.FloatSet floatSetOf(float element1, float element2); + method public static androidx.collection.FloatSet floatSetOf(float element1, float element2, float element3); + method public static androidx.collection.FloatSet floatSetOf(float... elements); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2, float element3); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float... elements); + } + + public abstract sealed class IntFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(int key); + method public final int getCapacity(); + method public final float getOrDefault(int key, float defaultValue); + method public final inline float getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class IntFloatMapKt { + method public static inline androidx.collection.IntFloatMap buildIntFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntFloatMap buildIntFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntFloatMap emptyIntFloatMap(); + method public static androidx.collection.IntFloatMap intFloatMapOf(); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5); + } + + public abstract sealed class IntIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(int key); + method public final int getCapacity(); + method public final int getOrDefault(int key, int defaultValue); + method public final inline int getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class IntIntMapKt { + method public static inline androidx.collection.IntIntMap buildIntIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntIntMap buildIntIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntIntMap emptyIntIntMap(); + method public static androidx.collection.IntIntMap intIntMapOf(); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5); + } + + @kotlin.jvm.JvmInline public final value class IntIntPair { + ctor public IntIntPair(int first, int second); + method public inline operator int component1(); + method public inline operator int component2(); + property public final int first; + property public final long packedValue; + property public final int second; + field public final long packedValue; + } + + public abstract sealed class IntList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(int element); + method public final boolean containsAll(androidx.collection.IntList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final int elementAt(@IntRange(from=0L) int index); + method public final inline int elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final int first(); + method public final inline int first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator int get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(int element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final int last(); + method public final inline int last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(int element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + } + + public final class IntListKt { + method public static inline androidx.collection.IntList buildIntList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntList buildIntList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntList emptyIntList(); + method public static androidx.collection.IntList intListOf(); + method public static androidx.collection.IntList intListOf(int element1); + method public static androidx.collection.IntList intListOf(int element1, int element2); + method public static androidx.collection.IntList intListOf(int element1, int element2, int element3); + method public static androidx.collection.IntList intListOf(int... elements); + method public static inline androidx.collection.MutableIntList mutableIntListOf(); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2, int element3); + method public static inline androidx.collection.MutableIntList mutableIntListOf(int... elements); + } + + public abstract sealed class IntLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(int key); + method public final int getCapacity(); + method public final long getOrDefault(int key, long defaultValue); + method public final inline long getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class IntLongMapKt { + method public static inline androidx.collection.IntLongMap buildIntLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntLongMap buildIntLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntLongMap emptyIntLongMap(); + method public static androidx.collection.IntLongMap intLongMapOf(); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5); + } + + public abstract sealed class IntObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(int key); + method public final int getCapacity(); + method public final V getOrDefault(int key, V defaultValue); + method public final inline V getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class IntObjectMapKt { + method public static inline androidx.collection.IntObjectMap buildIntObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.IntObjectMap buildIntObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.IntObjectMap emptyIntObjectMap(); + method public static androidx.collection.IntObjectMap intObjectMapOf(); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5); + } + + public abstract sealed class IntSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(int element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline int first(); + method public final inline int first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @IntRange(from=0L) public final int size; + } + + public final class IntSetKt { + method public static inline androidx.collection.IntSet buildIntSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntSet buildIntSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntSet emptyIntSet(); + method public static androidx.collection.IntSet intSetOf(); + method public static androidx.collection.IntSet intSetOf(int element1); + method public static androidx.collection.IntSet intSetOf(int element1, int element2); + method public static androidx.collection.IntSet intSetOf(int element1, int element2, int element3); + method public static androidx.collection.IntSet intSetOf(int... elements); + method public static androidx.collection.MutableIntSet mutableIntSetOf(); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2, int element3); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int... elements); + } + + public abstract sealed class LongFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(long key); + method public final int getCapacity(); + method public final float getOrDefault(long key, float defaultValue); + method public final inline float getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class LongFloatMapKt { + method public static inline androidx.collection.LongFloatMap buildLongFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongFloatMap buildLongFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongFloatMap emptyLongFloatMap(); + method public static androidx.collection.LongFloatMap longFloatMapOf(); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5); + } + + public abstract sealed class LongIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(long key); + method public final int getCapacity(); + method public final int getOrDefault(long key, int defaultValue); + method public final inline int getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class LongIntMapKt { + method public static inline androidx.collection.LongIntMap buildLongIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongIntMap buildLongIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongIntMap emptyLongIntMap(); + method public static androidx.collection.LongIntMap longIntMapOf(); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5); + } + + public abstract sealed class LongList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(long element); + method public final boolean containsAll(androidx.collection.LongList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final long elementAt(@IntRange(from=0L) int index); + method public final inline long elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final long first(); + method public final inline long first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator long get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(long element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final long last(); + method public final inline long last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(long element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + } + + public final class LongListKt { + method public static inline androidx.collection.LongList buildLongList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongList buildLongList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongList emptyLongList(); + method public static androidx.collection.LongList longListOf(); + method public static androidx.collection.LongList longListOf(long element1); + method public static androidx.collection.LongList longListOf(long element1, long element2); + method public static androidx.collection.LongList longListOf(long element1, long element2, long element3); + method public static androidx.collection.LongList longListOf(long... elements); + method public static inline androidx.collection.MutableLongList mutableLongListOf(); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2, long element3); + method public static inline androidx.collection.MutableLongList mutableLongListOf(long... elements); + } + + public abstract sealed class LongLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(long key); + method public final int getCapacity(); + method public final long getOrDefault(long key, long defaultValue); + method public final inline long getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class LongLongMapKt { + method public static inline androidx.collection.LongLongMap buildLongLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongLongMap buildLongLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongLongMap emptyLongLongMap(); + method public static androidx.collection.LongLongMap longLongMapOf(); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5); + } + + public final class LongLongPair { + ctor public LongLongPair(long first, long second); + method public inline operator long component1(); + method public inline operator long component2(); + method public long getFirst(); + method public long getSecond(); + property public final long first; + property public final long second; + } + + public abstract sealed class LongObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(long key); + method public final int getCapacity(); + method public final V getOrDefault(long key, V defaultValue); + method public final inline V getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class LongObjectMapKt { + method public static inline androidx.collection.LongObjectMap buildLongObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.LongObjectMap buildLongObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.LongObjectMap emptyLongObjectMap(); + method public static androidx.collection.LongObjectMap longObjectMapOf(); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5); + } + + public abstract sealed class LongSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(long element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline long first(); + method public final inline long first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @IntRange(from=0L) public final int size; + } + + public final class LongSetKt { + method public static inline androidx.collection.LongSet buildLongSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongSet buildLongSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongSet emptyLongSet(); + method public static androidx.collection.LongSet longSetOf(); + method public static androidx.collection.LongSet longSetOf(long element1); + method public static androidx.collection.LongSet longSetOf(long element1, long element2); + method public static androidx.collection.LongSet longSetOf(long element1, long element2, long element3); + method public static androidx.collection.LongSet longSetOf(long... elements); + method public static androidx.collection.MutableLongSet mutableLongSetOf(); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2, long element3); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long... elements); + } + + public class LongSparseArray implements java.lang.Cloneable { + ctor public LongSparseArray(); + ctor public LongSparseArray(optional int initialCapacity); + method public void append(long key, E value); + method public void clear(); + method public androidx.collection.LongSparseArray clone(); + method public boolean containsKey(long key); + method public boolean containsValue(E value); + method @Deprecated public void delete(long key); + method public operator E? get(long key); + method public E get(long key, E defaultValue); + method public int indexOfKey(long key); + method public int indexOfValue(E value); + method public boolean isEmpty(); + method public long keyAt(int index); + method public void put(long key, E value); + method public void putAll(androidx.collection.LongSparseArray other); + method public E? putIfAbsent(long key, E value); + method public void remove(long key); + method public boolean remove(long key, E value); + method public void removeAt(int index); + method public E? replace(long key, E value); + method public boolean replace(long key, E oldValue, E newValue); + method public void setValueAt(int index, E value); + method public int size(); + method public E valueAt(int index); + } + + public final class LongSparseArrayKt { + method public static inline operator boolean contains(androidx.collection.LongSparseArray, long key); + method public static inline void forEach(androidx.collection.LongSparseArray, kotlin.jvm.functions.Function2 action); + method public static inline T getOrDefault(androidx.collection.LongSparseArray, long key, T defaultValue); + method public static inline T getOrElse(androidx.collection.LongSparseArray, long key, kotlin.jvm.functions.Function0 defaultValue); + method public static inline int getSize(androidx.collection.LongSparseArray); + method public static inline boolean isNotEmpty(androidx.collection.LongSparseArray); + method public static kotlin.collections.LongIterator keyIterator(androidx.collection.LongSparseArray); + method public static operator androidx.collection.LongSparseArray plus(androidx.collection.LongSparseArray, androidx.collection.LongSparseArray other); + method @Deprecated public static boolean remove(androidx.collection.LongSparseArray, long key, T value); + method public static inline operator void set(androidx.collection.LongSparseArray, long key, T value); + method public static java.util.Iterator valueIterator(androidx.collection.LongSparseArray); + } + + public class LruCache { + ctor public LruCache(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize); + method protected V? create(K key); + method public final int createCount(); + method protected void entryRemoved(boolean evicted, K key, V oldValue, V? newValue); + method public final void evictAll(); + method public final int evictionCount(); + method public final operator V? get(K key); + method public final int hitCount(); + method public final int maxSize(); + method public final int missCount(); + method public final V? put(K key, V value); + method public final int putCount(); + method public final V? remove(K key); + method public void resize(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize); + method public final int size(); + method protected int sizeOf(K key, V value); + method public final java.util.Map snapshot(); + method public void trimToSize(int maxSize); + } + + public final class LruCacheKt { + method public static inline androidx.collection.LruCache lruCache(int maxSize, optional kotlin.jvm.functions.Function2 sizeOf, optional kotlin.jvm.functions.Function1 create, optional kotlin.jvm.functions.Function4 onEntryRemoved); + } + + public final class MutableDoubleList extends androidx.collection.DoubleList { + ctor public MutableDoubleList(); + ctor public MutableDoubleList(optional int initialCapacity); + method public boolean add(double element); + method public void add(@IntRange(from=0L) int index, double element); + method public inline boolean addAll(androidx.collection.DoubleList elements); + method public inline boolean addAll(double[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.DoubleList elements); + method public boolean addAll(@IntRange(from=0L) int index, double[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.DoubleList elements); + method public inline operator void minusAssign(double element); + method public operator void minusAssign(double[] elements); + method public inline operator void plusAssign(androidx.collection.DoubleList elements); + method public inline operator void plusAssign(double element); + method public inline operator void plusAssign(double[] elements); + method public boolean remove(double element); + method public boolean removeAll(androidx.collection.DoubleList elements); + method public boolean removeAll(double[] elements); + method public double removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.DoubleList elements); + method public boolean retainAll(double[] elements); + method public operator double set(@IntRange(from=0L) int index, double element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableFloatFloatMap extends androidx.collection.FloatFloatMap { + ctor public MutableFloatFloatMap(); + ctor public MutableFloatFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatFloatMap from); + method public void put(float key, float value); + method public float put(float key, float value, float default); + method public void putAll(androidx.collection.FloatFloatMap from); + method public void remove(float key); + method public boolean remove(float key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(float key, float value); + method public int trim(); + } + + public final class MutableFloatIntMap extends androidx.collection.FloatIntMap { + ctor public MutableFloatIntMap(); + ctor public MutableFloatIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatIntMap from); + method public void put(float key, int value); + method public int put(float key, int value, int default); + method public void putAll(androidx.collection.FloatIntMap from); + method public void remove(float key); + method public boolean remove(float key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(float key, int value); + method public int trim(); + } + + public final class MutableFloatList extends androidx.collection.FloatList { + ctor public MutableFloatList(); + ctor public MutableFloatList(optional int initialCapacity); + method public boolean add(float element); + method public void add(@IntRange(from=0L) int index, float element); + method public inline boolean addAll(androidx.collection.FloatList elements); + method public inline boolean addAll(float[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.FloatList elements); + method public boolean addAll(@IntRange(from=0L) int index, float[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.FloatList elements); + method public inline operator void minusAssign(float element); + method public operator void minusAssign(float[] elements); + method public inline operator void plusAssign(androidx.collection.FloatList elements); + method public inline operator void plusAssign(float element); + method public inline operator void plusAssign(float[] elements); + method public boolean remove(float element); + method public boolean removeAll(androidx.collection.FloatList elements); + method public boolean removeAll(float[] elements); + method public float removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.FloatList elements); + method public boolean retainAll(float[] elements); + method public operator float set(@IntRange(from=0L) int index, float element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableFloatLongMap extends androidx.collection.FloatLongMap { + ctor public MutableFloatLongMap(); + ctor public MutableFloatLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatLongMap from); + method public void put(float key, long value); + method public long put(float key, long value, long default); + method public void putAll(androidx.collection.FloatLongMap from); + method public void remove(float key); + method public boolean remove(float key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(float key, long value); + method public int trim(); + } + + public final class MutableFloatObjectMap extends androidx.collection.FloatObjectMap { + ctor public MutableFloatObjectMap(); + ctor public MutableFloatObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatObjectMap from); + method public V? put(float key, V value); + method public void putAll(androidx.collection.FloatObjectMap from); + method public V? remove(float key); + method public boolean remove(float key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(float key, V value); + method public int trim(); + } + + public final class MutableFloatSet extends androidx.collection.FloatSet { + ctor public MutableFloatSet(); + ctor public MutableFloatSet(optional int initialCapacity); + method public boolean add(float element); + method public boolean addAll(androidx.collection.FloatSet elements); + method public boolean addAll(float[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.FloatSet elements); + method public operator void minusAssign(float element); + method public operator void minusAssign(float[] elements); + method public operator void plusAssign(androidx.collection.FloatSet elements); + method public operator void plusAssign(float element); + method public operator void plusAssign(float[] elements); + method public boolean remove(float element); + method public boolean removeAll(androidx.collection.FloatSet elements); + method public boolean removeAll(float[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableIntFloatMap extends androidx.collection.IntFloatMap { + ctor public MutableIntFloatMap(); + ctor public MutableIntFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntFloatMap from); + method public void put(int key, float value); + method public float put(int key, float value, float default); + method public void putAll(androidx.collection.IntFloatMap from); + method public void remove(int key); + method public boolean remove(int key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(int key, float value); + method public int trim(); + } + + public final class MutableIntIntMap extends androidx.collection.IntIntMap { + ctor public MutableIntIntMap(); + ctor public MutableIntIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntIntMap from); + method public void put(int key, int value); + method public int put(int key, int value, int default); + method public void putAll(androidx.collection.IntIntMap from); + method public void remove(int key); + method public boolean remove(int key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(int key, int value); + method public int trim(); + } + + public final class MutableIntList extends androidx.collection.IntList { + ctor public MutableIntList(); + ctor public MutableIntList(optional int initialCapacity); + method public boolean add(int element); + method public void add(@IntRange(from=0L) int index, int element); + method public inline boolean addAll(androidx.collection.IntList elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.IntList elements); + method public boolean addAll(@IntRange(from=0L) int index, int[] elements); + method public inline boolean addAll(int[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.IntList elements); + method public inline operator void minusAssign(int element); + method public operator void minusAssign(int[] elements); + method public inline operator void plusAssign(androidx.collection.IntList elements); + method public inline operator void plusAssign(int element); + method public inline operator void plusAssign(int[] elements); + method public boolean remove(int element); + method public boolean removeAll(androidx.collection.IntList elements); + method public boolean removeAll(int[] elements); + method public int removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.IntList elements); + method public boolean retainAll(int[] elements); + method public operator int set(@IntRange(from=0L) int index, int element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableIntLongMap extends androidx.collection.IntLongMap { + ctor public MutableIntLongMap(); + ctor public MutableIntLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntLongMap from); + method public void put(int key, long value); + method public long put(int key, long value, long default); + method public void putAll(androidx.collection.IntLongMap from); + method public void remove(int key); + method public boolean remove(int key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(int key, long value); + method public int trim(); + } + + public final class MutableIntObjectMap extends androidx.collection.IntObjectMap { + ctor public MutableIntObjectMap(); + ctor public MutableIntObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntObjectMap from); + method public V? put(int key, V value); + method public void putAll(androidx.collection.IntObjectMap from); + method public V? remove(int key); + method public boolean remove(int key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(int key, V value); + method public int trim(); + } + + public final class MutableIntSet extends androidx.collection.IntSet { + ctor public MutableIntSet(); + ctor public MutableIntSet(optional int initialCapacity); + method public boolean add(int element); + method public boolean addAll(androidx.collection.IntSet elements); + method public boolean addAll(int[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.IntSet elements); + method public operator void minusAssign(int element); + method public operator void minusAssign(int[] elements); + method public operator void plusAssign(androidx.collection.IntSet elements); + method public operator void plusAssign(int element); + method public operator void plusAssign(int[] elements); + method public boolean remove(int element); + method public boolean removeAll(androidx.collection.IntSet elements); + method public boolean removeAll(int[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableLongFloatMap extends androidx.collection.LongFloatMap { + ctor public MutableLongFloatMap(); + ctor public MutableLongFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongFloatMap from); + method public void put(long key, float value); + method public float put(long key, float value, float default); + method public void putAll(androidx.collection.LongFloatMap from); + method public void remove(long key); + method public boolean remove(long key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(long key, float value); + method public int trim(); + } + + public final class MutableLongIntMap extends androidx.collection.LongIntMap { + ctor public MutableLongIntMap(); + ctor public MutableLongIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongIntMap from); + method public void put(long key, int value); + method public int put(long key, int value, int default); + method public void putAll(androidx.collection.LongIntMap from); + method public void remove(long key); + method public boolean remove(long key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(long key, int value); + method public int trim(); + } + + public final class MutableLongList extends androidx.collection.LongList { + ctor public MutableLongList(); + ctor public MutableLongList(optional int initialCapacity); + method public void add(@IntRange(from=0L) int index, long element); + method public boolean add(long element); + method public inline boolean addAll(androidx.collection.LongList elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.LongList elements); + method public boolean addAll(@IntRange(from=0L) int index, long[] elements); + method public inline boolean addAll(long[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.LongList elements); + method public inline operator void minusAssign(long element); + method public operator void minusAssign(long[] elements); + method public inline operator void plusAssign(androidx.collection.LongList elements); + method public inline operator void plusAssign(long element); + method public inline operator void plusAssign(long[] elements); + method public boolean remove(long element); + method public boolean removeAll(androidx.collection.LongList elements); + method public boolean removeAll(long[] elements); + method public long removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.LongList elements); + method public boolean retainAll(long[] elements); + method public operator long set(@IntRange(from=0L) int index, long element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableLongLongMap extends androidx.collection.LongLongMap { + ctor public MutableLongLongMap(); + ctor public MutableLongLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongLongMap from); + method public void put(long key, long value); + method public long put(long key, long value, long default); + method public void putAll(androidx.collection.LongLongMap from); + method public void remove(long key); + method public boolean remove(long key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(long key, long value); + method public int trim(); + } + + public final class MutableLongObjectMap extends androidx.collection.LongObjectMap { + ctor public MutableLongObjectMap(); + ctor public MutableLongObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongObjectMap from); + method public V? put(long key, V value); + method public void putAll(androidx.collection.LongObjectMap from); + method public V? remove(long key); + method public boolean remove(long key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(long key, V value); + method public int trim(); + } + + public final class MutableLongSet extends androidx.collection.LongSet { + ctor public MutableLongSet(); + ctor public MutableLongSet(optional int initialCapacity); + method public boolean add(long element); + method public boolean addAll(androidx.collection.LongSet elements); + method public boolean addAll(long[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.LongSet elements); + method public operator void minusAssign(long element); + method public operator void minusAssign(long[] elements); + method public operator void plusAssign(androidx.collection.LongSet elements); + method public operator void plusAssign(long element); + method public operator void plusAssign(long[] elements); + method public boolean remove(long element); + method public boolean removeAll(androidx.collection.LongSet elements); + method public boolean removeAll(long[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableObjectFloatMap extends androidx.collection.ObjectFloatMap { + ctor public MutableObjectFloatMap(); + ctor public MutableObjectFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectFloatMap from); + method public void put(K key, float value); + method public float put(K key, float value, float default); + method public void putAll(androidx.collection.ObjectFloatMap from); + method public void remove(K key); + method public boolean remove(K key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(K key, float value); + method public int trim(); + } + + public final class MutableObjectIntMap extends androidx.collection.ObjectIntMap { + ctor public MutableObjectIntMap(); + ctor public MutableObjectIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectIntMap from); + method public void put(K key, int value); + method public int put(K key, int value, int default); + method public void putAll(androidx.collection.ObjectIntMap from); + method public void remove(K key); + method public boolean remove(K key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(K key, int value); + method public int trim(); + } + + public final class MutableObjectList extends androidx.collection.ObjectList { + ctor public MutableObjectList(); + ctor public MutableObjectList(optional int initialCapacity); + method public boolean add(E element); + method public void add(@IntRange(from=0L) int index, E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.ObjectList elements); + method public boolean addAll(@IntRange(from=0L) int index, E[] elements); + method public boolean addAll(@IntRange(from=0L) int index, java.util.Collection elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(java.util.List elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.List asList(); + method public java.util.List asMutableList(); + method public void clear(); + method public inline void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public inline operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(java.util.List elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public inline operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(java.util.List elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(java.util.List elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method public E removeAt(@IntRange(from=0L) int index); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.ObjectList elements); + method public boolean retainAll(E[] elements); + method public boolean retainAll(Iterable elements); + method public boolean retainAll(java.util.Collection elements); + method public boolean retainAll(kotlin.sequences.Sequence elements); + method public operator E set(@IntRange(from=0L) int index, E element); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableObjectLongMap extends androidx.collection.ObjectLongMap { + ctor public MutableObjectLongMap(); + ctor public MutableObjectLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectLongMap from); + method public void put(K key, long value); + method public long put(K key, long value, long default); + method public void putAll(androidx.collection.ObjectLongMap from); + method public void remove(K key); + method public boolean remove(K key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(K key, long value); + method public int trim(); + } + + public final class MutableOrderedScatterSet extends androidx.collection.OrderedScatterSet { + ctor public MutableOrderedScatterSet(); + ctor public MutableOrderedScatterSet(optional int initialCapacity); + method public boolean add(E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.OrderedScatterSet elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.Set asMutableSet(); + method public void clear(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.OrderedScatterSet elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public boolean retainAll(androidx.collection.OrderedScatterSet elements); + method public boolean retainAll(androidx.collection.ScatterSet elements); + method public boolean retainAll(java.util.Collection elements); + method public inline boolean retainAll(kotlin.jvm.functions.Function1 predicate); + method @IntRange(from=0L) public int trim(); + method public void trimToSize(int maxSize); + } + + public final class MutableScatterMap extends androidx.collection.ScatterMap { + ctor public MutableScatterMap(); + ctor public MutableScatterMap(optional int initialCapacity); + method public java.util.Map asMutableMap(); + method public void clear(); + method public inline V compute(K key, kotlin.jvm.functions.Function2 computeBlock); + method public inline V getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ObjectList keys); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ScatterMap from); + method public inline operator void plusAssign(Iterable> pairs); + method public inline operator void plusAssign(java.util.Map from); + method public inline operator void plusAssign(kotlin.Pair pair); + method public inline operator void plusAssign(kotlin.Pair[] pairs); + method public inline operator void plusAssign(kotlin.sequences.Sequence> pairs); + method public V? put(K key, V value); + method public void putAll(androidx.collection.ScatterMap from); + method public void putAll(Iterable> pairs); + method public void putAll(java.util.Map from); + method public void putAll(kotlin.Pair[] pairs); + method public void putAll(kotlin.sequences.Sequence> pairs); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method public operator void set(K key, V value); + method public int trim(); + } + + public final class MutableScatterSet extends androidx.collection.ScatterSet { + ctor public MutableScatterSet(); + ctor public MutableScatterSet(optional int initialCapacity); + method public boolean add(E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.OrderedScatterSet elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.Set asMutableSet(); + method public void clear(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.OrderedScatterSet elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public boolean retainAll(androidx.collection.OrderedScatterSet elements); + method public boolean retainAll(androidx.collection.ScatterSet elements); + method public boolean retainAll(java.util.Collection elements); + method public boolean retainAll(kotlin.jvm.functions.Function1 predicate); + method @IntRange(from=0L) public int trim(); + } + + public abstract sealed class ObjectFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(K key); + method public final int getCapacity(); + method public final float getOrDefault(K key, float defaultValue); + method public final inline float getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class ObjectFloatMapKt { + method public static inline androidx.collection.ObjectFloatMap buildObjectFloatMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectFloatMap buildObjectFloatMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectFloatMap emptyObjectFloatMap(); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5); + method public static androidx.collection.ObjectFloatMap objectFloatMap(); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5); + } + + public abstract sealed class ObjectIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(K key); + method public final int getCapacity(); + method public final int getOrDefault(K key, int defaultValue); + method public final inline int getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class ObjectIntMapKt { + method public static inline androidx.collection.ObjectIntMap buildObjectIntMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectIntMap buildObjectIntMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectIntMap emptyObjectIntMap(); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5); + method public static androidx.collection.ObjectIntMap objectIntMap(); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5); + } + + public abstract sealed class ObjectList { + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public abstract java.util.List asList(); + method public final operator boolean contains(E element); + method public final boolean containsAll(androidx.collection.ObjectList elements); + method public final boolean containsAll(E[] elements); + method public final boolean containsAll(Iterable elements); + method public final boolean containsAll(java.util.List elements); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E elementAt(@IntRange(from=0L) int index); + method public final inline E elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator E get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final int getSize(); + method public final int indexOf(E element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final E last(); + method public final inline E last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(E element); + method public final inline E? lastOrNull(); + method public final inline E? lastOrNull(kotlin.jvm.functions.Function1 predicate); + method public final boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final int size; + } + + public final class ObjectListKt { + method public static androidx.collection.ObjectList emptyObjectList(); + method public static inline androidx.collection.MutableObjectList mutableObjectListOf(); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1, E element2); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1, E element2, E element3); + method public static inline androidx.collection.MutableObjectList mutableObjectListOf(E... elements); + method public static androidx.collection.ObjectList objectListOf(); + method public static androidx.collection.ObjectList objectListOf(E element1); + method public static androidx.collection.ObjectList objectListOf(E element1, E element2); + method public static androidx.collection.ObjectList objectListOf(E element1, E element2, E element3); + method public static androidx.collection.ObjectList objectListOf(E... elements); + } + + public abstract sealed class ObjectLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(K key); + method public final int getCapacity(); + method public final long getOrDefault(K key, long defaultValue); + method public final inline long getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class ObjectLongMapKt { + method public static inline androidx.collection.ObjectLongMap buildObjectLongMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectLongMap buildObjectLongMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectLongMap emptyObjectLongMap(); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5); + method public static androidx.collection.ObjectLongMap objectLongMap(); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5); + } + + public abstract sealed class OrderedScatterSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final java.util.Set asSet(); + method public final operator boolean contains(E element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReverse(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final E last(); + method public final inline E last(kotlin.jvm.functions.Function1 predicate); + method public final inline E? lastOrNull(kotlin.jvm.functions.Function1 predicate); + method public final boolean none(); + method public final inline java.util.List toList(); + property @IntRange(from=0L) public final int capacity; + property @IntRange(from=0L) public final int size; + } + + public final class OrderedScatterSetKt { + method public static androidx.collection.OrderedScatterSet emptyOrderedScatterSet(); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1, E element2); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E... elements); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1, E element2); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E... elements); + } + + public abstract sealed class ScatterMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final java.util.Map asMap(); + method public final operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(K key); + method public final int getCapacity(); + method public final V getOrDefault(K key, V defaultValue); + method public final inline V getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function2? transform); + method public final boolean none(); + property public final int capacity; + property public final int size; + } + + public final class ScatterMapKt { + method public static androidx.collection.ScatterMap emptyScatterMap(); + method public static androidx.collection.MutableScatterMap mutableScatterMapOf(); + method public static androidx.collection.MutableScatterMap mutableScatterMapOf(kotlin.Pair... pairs); + } + + public abstract sealed class ScatterSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final java.util.Set asSet(); + method public final operator boolean contains(E element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @IntRange(from=0L) public final int size; + } + + public final class ScatterSetKt { + method public static androidx.collection.ScatterSet emptyScatterSet(); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1, E element2); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E... elements); + method public static androidx.collection.ScatterSet scatterSetOf(); + method public static androidx.collection.ScatterSet scatterSetOf(E element1); + method public static androidx.collection.ScatterSet scatterSetOf(E element1, E element2); + method public static androidx.collection.ScatterSet scatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.ScatterSet scatterSetOf(E... elements); + } + + public final class SieveCache { + ctor public SieveCache(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize, optional @IntRange(from=0L, to=androidx.collection.SieveCacheKt.MaxSize) int initialCapacity, optional kotlin.jvm.functions.Function2 sizeOf, optional kotlin.jvm.functions.Function1 createValueFromKey, optional kotlin.jvm.functions.Function4 onEntryRemoved); + method public inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public boolean any(); + method public inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public operator boolean contains(K key); + method public boolean containsKey(K key); + method public boolean containsValue(V value); + method public int count(); + method public inline int count(kotlin.jvm.functions.Function2 predicate); + method public void evictAll(); + method public inline void forEach(kotlin.jvm.functions.Function2 block); + method public inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public operator V? get(K key); + method public int getCapacity(); + method public int getCount(); + method public int getMaxSize(); + method public int getSize(); + method public boolean isEmpty(); + method public boolean isNotEmpty(); + method public inline operator void minusAssign(androidx.collection.ObjectList keys); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public boolean none(); + method public inline operator void plusAssign(androidx.collection.ScatterMap from); + method public inline operator void plusAssign(androidx.collection.SieveCache from); + method public inline operator void plusAssign(Iterable> pairs); + method public inline operator void plusAssign(java.util.Map from); + method public inline operator void plusAssign(kotlin.Pair pair); + method public inline operator void plusAssign(kotlin.Pair[] pairs); + method public inline operator void plusAssign(kotlin.sequences.Sequence> pairs); + method public V? put(K key, V value); + method public void putAll(androidx.collection.ScatterMap from); + method public void putAll(androidx.collection.SieveCache from); + method public void putAll(Iterable> pairs); + method public void putAll(java.util.Map from); + method public void putAll(kotlin.Pair[] pairs); + method public void putAll(kotlin.sequences.Sequence> pairs); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public void removeIf(kotlin.jvm.functions.Function2 predicate); + method public void resize(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize); + method public inline operator void set(K key, V value); + method public void trimToSize(int maxSize); + property public final int capacity; + property public final int count; + property public final int maxSize; + property public final int size; + } + + public class SimpleArrayMap { + ctor public SimpleArrayMap(); + ctor public SimpleArrayMap(androidx.collection.SimpleArrayMap? map); + ctor public SimpleArrayMap(optional int capacity); + method public void clear(); + method public boolean containsKey(K key); + method public boolean containsValue(V value); + method public void ensureCapacity(int minimumCapacity); + method public operator V? get(K key); + method public V getOrDefault(Object? key, V defaultValue); + method public int indexOfKey(K key); + method public boolean isEmpty(); + method public K keyAt(int index); + method public V? put(K key, V value); + method public void putAll(androidx.collection.SimpleArrayMap map); + method public V? putIfAbsent(K key, V value); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public V removeAt(int index); + method public V? replace(K key, V value); + method public boolean replace(K key, V oldValue, V newValue); + method public V setValueAt(int index, V value); + method public int size(); + method public V valueAt(int index); + } + + public class SparseArrayCompat implements java.lang.Cloneable { + ctor public SparseArrayCompat(); + ctor public SparseArrayCompat(optional int initialCapacity); + method public void append(int key, E value); + method public void clear(); + method public androidx.collection.SparseArrayCompat clone(); + method public boolean containsKey(int key); + method public boolean containsValue(E value); + method @Deprecated public void delete(int key); + method public operator E? get(int key); + method public E get(int key, E defaultValue); + method public final boolean getIsEmpty(); + method public int indexOfKey(int key); + method public int indexOfValue(E value); + method public boolean isEmpty(); + method public int keyAt(int index); + method public void put(int key, E value); + method public void putAll(androidx.collection.SparseArrayCompat other); + method public E? putIfAbsent(int key, E value); + method public void remove(int key); + method public boolean remove(int key, Object? value); + method public void removeAt(int index); + method public void removeAtRange(int index, int size); + method public E? replace(int key, E value); + method public boolean replace(int key, E oldValue, E newValue); + method public void setValueAt(int index, E value); + method public int size(); + method public E valueAt(int index); + property public final boolean isEmpty; + } + + public final class SparseArrayKt { + method public static inline operator boolean contains(androidx.collection.SparseArrayCompat, int key); + method public static inline void forEach(androidx.collection.SparseArrayCompat, kotlin.jvm.functions.Function2 action); + method public static inline T getOrDefault(androidx.collection.SparseArrayCompat, int key, T defaultValue); + method public static inline T getOrElse(androidx.collection.SparseArrayCompat, int key, kotlin.jvm.functions.Function0 defaultValue); + method public static inline int getSize(androidx.collection.SparseArrayCompat); + method public static inline boolean isNotEmpty(androidx.collection.SparseArrayCompat); + method public static kotlin.collections.IntIterator keyIterator(androidx.collection.SparseArrayCompat); + method public static operator androidx.collection.SparseArrayCompat plus(androidx.collection.SparseArrayCompat, androidx.collection.SparseArrayCompat other); + method @Deprecated public static boolean remove(androidx.collection.SparseArrayCompat, int key, T value); + method public static inline operator void set(androidx.collection.SparseArrayCompat, int key, T value); + method public static java.util.Iterator valueIterator(androidx.collection.SparseArrayCompat); + } + +} + diff --git a/collection/collection/api/restricted_1.5.0-beta01.txt b/collection/collection/api/restricted_1.5.0-beta01.txt new file mode 100644 index 0000000000000..385c7f57ae794 --- /dev/null +++ b/collection/collection/api/restricted_1.5.0-beta01.txt @@ -0,0 +1,2627 @@ +// Signature format: 4.0 +package androidx.collection { + + public class ArrayMap extends androidx.collection.SimpleArrayMap implements java.util.Map { + ctor public ArrayMap(); + ctor public ArrayMap(androidx.collection.SimpleArrayMap?); + ctor public ArrayMap(int); + method public boolean containsAll(java.util.Collection); + method public boolean containsKey(Object?); + method public boolean containsValue(Object?); + method public java.util.Set!> entrySet(); + method public V! get(Object?); + method public java.util.Set keySet(); + method public void putAll(java.util.Map); + method public V! remove(Object?); + method public boolean removeAll(java.util.Collection); + method public boolean retainAll(java.util.Collection); + method public java.util.Collection values(); + } + + public final class ArrayMapKt { + method public static inline androidx.collection.ArrayMap arrayMapOf(); + method public static androidx.collection.ArrayMap arrayMapOf(kotlin.Pair... pairs); + } + + public final class ArraySet implements java.util.Collection kotlin.jvm.internal.markers.KMutableCollection kotlin.jvm.internal.markers.KMutableSet java.util.Set { + ctor public ArraySet(); + ctor public ArraySet(androidx.collection.ArraySet? set); + ctor public ArraySet(E[]? array); + ctor public ArraySet(optional int capacity); + ctor public ArraySet(java.util.Collection? set); + method public boolean add(E element); + method public void addAll(androidx.collection.ArraySet array); + method public boolean addAll(java.util.Collection elements); + method public void clear(); + method public operator boolean contains(E element); + method public boolean containsAll(java.util.Collection elements); + method public void ensureCapacity(int minimumCapacity); + method public int getSize(); + method public int indexOf(Object? key); + method public boolean isEmpty(); + method public java.util.Iterator iterator(); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ArraySet array); + method public boolean removeAll(java.util.Collection elements); + method public E removeAt(int index); + method public boolean retainAll(java.util.Collection elements); + method public Object?[] toArray(); + method public T[] toArray(T[] array); + method public E valueAt(int index); + property public int size; + } + + public final class ArraySetKt { + method public static inline androidx.collection.ArraySet arraySetOf(); + method public static androidx.collection.ArraySet arraySetOf(T... values); + } + + public final class CircularArray { + ctor public CircularArray(); + ctor public CircularArray(optional int minCapacity); + method public void addFirst(E element); + method public void addLast(E element); + method public void clear(); + method public operator E get(int index); + method public E getFirst(); + method public E getLast(); + method public boolean isEmpty(); + method public E popFirst(); + method public E popLast(); + method public void removeFromEnd(int count); + method public void removeFromStart(int count); + method public int size(); + property public final E first; + property public final E last; + } + + public final class CircularIntArray { + ctor public CircularIntArray(); + ctor public CircularIntArray(optional int minCapacity); + method public void addFirst(int element); + method public void addLast(int element); + method public void clear(); + method public operator int get(int index); + method public int getFirst(); + method public int getLast(); + method public boolean isEmpty(); + method public int popFirst(); + method public int popLast(); + method public void removeFromEnd(int count); + method public void removeFromStart(int count); + method public int size(); + property public final int first; + property public final int last; + } + + public abstract sealed class DoubleList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(double element); + method public final boolean containsAll(androidx.collection.DoubleList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final double elementAt(@IntRange(from=0L) int index); + method public final inline double elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final double first(); + method public final inline double first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator double get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(double element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final double last(); + method public final inline double last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(double element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property @kotlin.PublishedApi internal final int _size; + property @kotlin.PublishedApi internal final double[] content; + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + field @kotlin.PublishedApi internal int _size; + field @kotlin.PublishedApi internal double[] content; + } + + public final class DoubleListKt { + method public static inline androidx.collection.DoubleList buildDoubleList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.DoubleList buildDoubleList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.DoubleList doubleListOf(); + method public static androidx.collection.DoubleList doubleListOf(double element1); + method public static androidx.collection.DoubleList doubleListOf(double element1, double element2); + method public static androidx.collection.DoubleList doubleListOf(double element1, double element2, double element3); + method public static androidx.collection.DoubleList doubleListOf(double... elements); + method public static androidx.collection.DoubleList emptyDoubleList(); + method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2); + method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2, double element3); + method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(double... elements); + } + + public abstract sealed class FloatFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(float key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(float key); + method public final int getCapacity(); + method public final float getOrDefault(float key, float defaultValue); + method public final inline float getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final float[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final float[] values; + field @kotlin.PublishedApi internal float[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal float[] values; + } + + public final class FloatFloatMapKt { + method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatFloatMap emptyFloatFloatMap(); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4); + method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4); + method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5); + } + + @kotlin.jvm.JvmInline public final value class FloatFloatPair { + ctor public FloatFloatPair(float first, float second); + method public inline operator float component1(); + method public inline operator float component2(); + property public final inline float first; + property public final long packedValue; + property public final inline float second; + field public final long packedValue; + } + + public abstract sealed class FloatIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(float key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(float key); + method public final int getCapacity(); + method public final int getOrDefault(float key, int defaultValue); + method public final inline int getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final float[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final int[] values; + field @kotlin.PublishedApi internal float[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal int[] values; + } + + public final class FloatIntMapKt { + method public static inline androidx.collection.FloatIntMap buildFloatIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatIntMap buildFloatIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatIntMap emptyFloatIntMap(); + method public static androidx.collection.FloatIntMap floatIntMapOf(); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4); + method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4); + method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5); + } + + public abstract sealed class FloatList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(float element); + method public final boolean containsAll(androidx.collection.FloatList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final float elementAt(@IntRange(from=0L) int index); + method public final inline float elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final float first(); + method public final inline float first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator float get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(float element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final float last(); + method public final inline float last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(float element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property @kotlin.PublishedApi internal final int _size; + property @kotlin.PublishedApi internal final float[] content; + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + field @kotlin.PublishedApi internal int _size; + field @kotlin.PublishedApi internal float[] content; + } + + public final class FloatListKt { + method public static inline androidx.collection.FloatList buildFloatList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatList buildFloatList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatList emptyFloatList(); + method public static androidx.collection.FloatList floatListOf(); + method public static androidx.collection.FloatList floatListOf(float element1); + method public static androidx.collection.FloatList floatListOf(float element1, float element2); + method public static androidx.collection.FloatList floatListOf(float element1, float element2, float element3); + method public static androidx.collection.FloatList floatListOf(float... elements); + method public static inline androidx.collection.MutableFloatList mutableFloatListOf(); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2); + method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2, float element3); + method public static inline androidx.collection.MutableFloatList mutableFloatListOf(float... elements); + } + + public abstract sealed class FloatLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(float key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(float key); + method public final int getCapacity(); + method public final long getOrDefault(float key, long defaultValue); + method public final inline long getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final float[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final long[] values; + field @kotlin.PublishedApi internal float[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal long[] values; + } + + public final class FloatLongMapKt { + method public static inline androidx.collection.FloatLongMap buildFloatLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatLongMap buildFloatLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatLongMap emptyFloatLongMap(); + method public static androidx.collection.FloatLongMap floatLongMapOf(); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4); + method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4); + method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5); + } + + public abstract sealed class FloatObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(float key); + method public final boolean containsKey(float key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(float key); + method public final int getCapacity(); + method public final V getOrDefault(float key, V defaultValue); + method public final inline V getOrElse(float key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final float[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final Object?[] values; + field @kotlin.PublishedApi internal float[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal Object?[] values; + } + + public final class FloatObjectMapKt { + method public static inline androidx.collection.FloatObjectMap buildFloatObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.FloatObjectMap buildFloatObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.FloatObjectMap emptyFloatObjectMap(); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4); + method public static androidx.collection.FloatObjectMap floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4); + method public static androidx.collection.MutableFloatObjectMap mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5); + } + + public abstract sealed class FloatSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(float element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline float first(); + method public final inline float first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @kotlin.PublishedApi internal final float[] elements; + property @kotlin.PublishedApi internal final long[] metadata; + property @IntRange(from=0L) public final int size; + field @kotlin.PublishedApi internal float[] elements; + field @kotlin.PublishedApi internal long[] metadata; + } + + public final class FloatSetKt { + method public static inline androidx.collection.FloatSet buildFloatSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.FloatSet buildFloatSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.FloatSet emptyFloatSet(); + method public static androidx.collection.FloatSet floatSetOf(); + method public static androidx.collection.FloatSet floatSetOf(float element1); + method public static androidx.collection.FloatSet floatSetOf(float element1, float element2); + method public static androidx.collection.FloatSet floatSetOf(float element1, float element2, float element3); + method public static androidx.collection.FloatSet floatSetOf(float... elements); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2, float element3); + method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float... elements); + } + + public abstract sealed class IntFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(int key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(int key); + method public final int getCapacity(); + method public final float getOrDefault(int key, float defaultValue); + method public final inline float getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final int[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final float[] values; + field @kotlin.PublishedApi internal int[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal float[] values; + } + + public final class IntFloatMapKt { + method public static inline androidx.collection.IntFloatMap buildIntFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntFloatMap buildIntFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntFloatMap emptyIntFloatMap(); + method public static androidx.collection.IntFloatMap intFloatMapOf(); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4); + method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4); + method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5); + } + + public abstract sealed class IntIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(int key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(int key); + method public final int getCapacity(); + method public final int getOrDefault(int key, int defaultValue); + method public final inline int getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final int[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final int[] values; + field @kotlin.PublishedApi internal int[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal int[] values; + } + + public final class IntIntMapKt { + method public static inline androidx.collection.IntIntMap buildIntIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntIntMap buildIntIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntIntMap emptyIntIntMap(); + method public static androidx.collection.IntIntMap intIntMapOf(); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4); + method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4); + method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5); + } + + @kotlin.jvm.JvmInline public final value class IntIntPair { + ctor public IntIntPair(int first, int second); + method public inline operator int component1(); + method public inline operator int component2(); + property public final int first; + property public final long packedValue; + property public final int second; + field public final long packedValue; + } + + public abstract sealed class IntList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(int element); + method public final boolean containsAll(androidx.collection.IntList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final int elementAt(@IntRange(from=0L) int index); + method public final inline int elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final int first(); + method public final inline int first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator int get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(int element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final int last(); + method public final inline int last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(int element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property @kotlin.PublishedApi internal final int _size; + property @kotlin.PublishedApi internal final int[] content; + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + field @kotlin.PublishedApi internal int _size; + field @kotlin.PublishedApi internal int[] content; + } + + public final class IntListKt { + method public static inline androidx.collection.IntList buildIntList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntList buildIntList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntList emptyIntList(); + method public static androidx.collection.IntList intListOf(); + method public static androidx.collection.IntList intListOf(int element1); + method public static androidx.collection.IntList intListOf(int element1, int element2); + method public static androidx.collection.IntList intListOf(int element1, int element2, int element3); + method public static androidx.collection.IntList intListOf(int... elements); + method public static inline androidx.collection.MutableIntList mutableIntListOf(); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2); + method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2, int element3); + method public static inline androidx.collection.MutableIntList mutableIntListOf(int... elements); + } + + public abstract sealed class IntLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(int key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(int key); + method public final int getCapacity(); + method public final long getOrDefault(int key, long defaultValue); + method public final inline long getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final int[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final long[] values; + field @kotlin.PublishedApi internal int[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal long[] values; + } + + public final class IntLongMapKt { + method public static inline androidx.collection.IntLongMap buildIntLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntLongMap buildIntLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntLongMap emptyIntLongMap(); + method public static androidx.collection.IntLongMap intLongMapOf(); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4); + method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4); + method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5); + } + + public abstract sealed class IntObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(int key); + method public final boolean containsKey(int key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(int key); + method public final int getCapacity(); + method public final V getOrDefault(int key, V defaultValue); + method public final inline V getOrElse(int key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final int[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final Object?[] values; + field @kotlin.PublishedApi internal int[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal Object?[] values; + } + + public final class IntObjectMapKt { + method public static inline androidx.collection.IntObjectMap buildIntObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.IntObjectMap buildIntObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.IntObjectMap emptyIntObjectMap(); + method public static androidx.collection.IntObjectMap intObjectMapOf(); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4); + method public static androidx.collection.IntObjectMap intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4); + method public static androidx.collection.MutableIntObjectMap mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5); + } + + public abstract sealed class IntSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(int element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline int first(); + method public final inline int first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @kotlin.PublishedApi internal final int[] elements; + property @kotlin.PublishedApi internal final long[] metadata; + property @IntRange(from=0L) public final int size; + field @kotlin.PublishedApi internal int[] elements; + field @kotlin.PublishedApi internal long[] metadata; + } + + public final class IntSetKt { + method public static inline androidx.collection.IntSet buildIntSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.IntSet buildIntSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.IntSet emptyIntSet(); + method public static androidx.collection.IntSet intSetOf(); + method public static androidx.collection.IntSet intSetOf(int element1); + method public static androidx.collection.IntSet intSetOf(int element1, int element2); + method public static androidx.collection.IntSet intSetOf(int element1, int element2, int element3); + method public static androidx.collection.IntSet intSetOf(int... elements); + method public static androidx.collection.MutableIntSet mutableIntSetOf(); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2, int element3); + method public static androidx.collection.MutableIntSet mutableIntSetOf(int... elements); + } + + public abstract sealed class LongFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(long key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(long key); + method public final int getCapacity(); + method public final float getOrDefault(long key, float defaultValue); + method public final inline float getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final long[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final float[] values; + field @kotlin.PublishedApi internal long[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal float[] values; + } + + public final class LongFloatMapKt { + method public static inline androidx.collection.LongFloatMap buildLongFloatMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongFloatMap buildLongFloatMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongFloatMap emptyLongFloatMap(); + method public static androidx.collection.LongFloatMap longFloatMapOf(); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4); + method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4); + method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5); + } + + public abstract sealed class LongIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(long key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(long key); + method public final int getCapacity(); + method public final int getOrDefault(long key, int defaultValue); + method public final inline int getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final long[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final int[] values; + field @kotlin.PublishedApi internal long[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal int[] values; + } + + public final class LongIntMapKt { + method public static inline androidx.collection.LongIntMap buildLongIntMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongIntMap buildLongIntMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongIntMap emptyLongIntMap(); + method public static androidx.collection.LongIntMap longIntMapOf(); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4); + method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4); + method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5); + } + + public abstract sealed class LongList { + method public final inline boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final int binarySearch(int element); + method public final int binarySearch(int element, optional int fromIndex); + method public final int binarySearch(int element, optional int fromIndex, optional int toIndex); + method public final operator boolean contains(long element); + method public final boolean containsAll(androidx.collection.LongList elements); + method public final inline int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final long elementAt(@IntRange(from=0L) int index); + method public final inline long elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final long first(); + method public final inline long first(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator long get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final inline int getSize(); + method public final int indexOf(long element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final inline boolean isEmpty(); + method public final inline boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final long last(); + method public final inline long last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(long element); + method public final inline boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property @kotlin.PublishedApi internal final int _size; + property @kotlin.PublishedApi internal final long[] content; + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final inline int size; + field @kotlin.PublishedApi internal int _size; + field @kotlin.PublishedApi internal long[] content; + } + + public final class LongListKt { + method public static inline androidx.collection.LongList buildLongList(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongList buildLongList(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongList emptyLongList(); + method public static androidx.collection.LongList longListOf(); + method public static androidx.collection.LongList longListOf(long element1); + method public static androidx.collection.LongList longListOf(long element1, long element2); + method public static androidx.collection.LongList longListOf(long element1, long element2, long element3); + method public static androidx.collection.LongList longListOf(long... elements); + method public static inline androidx.collection.MutableLongList mutableLongListOf(); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2); + method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2, long element3); + method public static inline androidx.collection.MutableLongList mutableLongListOf(long... elements); + } + + public abstract sealed class LongLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(long key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(long key); + method public final int getCapacity(); + method public final long getOrDefault(long key, long defaultValue); + method public final inline long getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final long[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final long[] values; + field @kotlin.PublishedApi internal long[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal long[] values; + } + + public final class LongLongMapKt { + method public static inline androidx.collection.LongLongMap buildLongLongMap(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongLongMap buildLongLongMap(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongLongMap emptyLongLongMap(); + method public static androidx.collection.LongLongMap longLongMapOf(); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4); + method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4); + method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5); + } + + public final class LongLongPair { + ctor public LongLongPair(long first, long second); + method public inline operator long component1(); + method public inline operator long component2(); + method public long getFirst(); + method public long getSecond(); + property public final long first; + property public final long second; + } + + public abstract sealed class LongObjectMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(long key); + method public final boolean containsKey(long key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(long key); + method public final int getCapacity(); + method public final V getOrDefault(long key, V defaultValue); + method public final inline V getOrElse(long key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final long[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final Object?[] values; + field @kotlin.PublishedApi internal long[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal Object?[] values; + } + + public final class LongObjectMapKt { + method public static inline androidx.collection.LongObjectMap buildLongObjectMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.LongObjectMap buildLongObjectMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.LongObjectMap emptyLongObjectMap(); + method public static androidx.collection.LongObjectMap longObjectMapOf(); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4); + method public static androidx.collection.LongObjectMap longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4); + method public static androidx.collection.MutableLongObjectMap mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5); + } + + public abstract sealed class LongSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final operator boolean contains(long element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final inline long first(); + method public final inline long first(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function1 transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @kotlin.PublishedApi internal final long[] elements; + property @kotlin.PublishedApi internal final long[] metadata; + property @IntRange(from=0L) public final int size; + field @kotlin.PublishedApi internal long[] elements; + field @kotlin.PublishedApi internal long[] metadata; + } + + public final class LongSetKt { + method public static inline androidx.collection.LongSet buildLongSet(int initialCapacity, kotlin.jvm.functions.Function1 builderAction); + method public static inline androidx.collection.LongSet buildLongSet(kotlin.jvm.functions.Function1 builderAction); + method public static androidx.collection.LongSet emptyLongSet(); + method public static androidx.collection.LongSet longSetOf(); + method public static androidx.collection.LongSet longSetOf(long element1); + method public static androidx.collection.LongSet longSetOf(long element1, long element2); + method public static androidx.collection.LongSet longSetOf(long element1, long element2, long element3); + method public static androidx.collection.LongSet longSetOf(long... elements); + method public static androidx.collection.MutableLongSet mutableLongSetOf(); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2, long element3); + method public static androidx.collection.MutableLongSet mutableLongSetOf(long... elements); + } + + public class LongSparseArray implements java.lang.Cloneable { + ctor public LongSparseArray(); + ctor public LongSparseArray(optional int initialCapacity); + method public void append(long key, E value); + method public void clear(); + method public androidx.collection.LongSparseArray clone(); + method public boolean containsKey(long key); + method public boolean containsValue(E value); + method @Deprecated public void delete(long key); + method public operator E? get(long key); + method public E get(long key, E defaultValue); + method public int indexOfKey(long key); + method public int indexOfValue(E value); + method public boolean isEmpty(); + method public long keyAt(int index); + method public void put(long key, E value); + method public void putAll(androidx.collection.LongSparseArray other); + method public E? putIfAbsent(long key, E value); + method public void remove(long key); + method public boolean remove(long key, E value); + method public void removeAt(int index); + method public E? replace(long key, E value); + method public boolean replace(long key, E oldValue, E newValue); + method public void setValueAt(int index, E value); + method public int size(); + method public E valueAt(int index); + } + + public final class LongSparseArrayKt { + method public static inline operator boolean contains(androidx.collection.LongSparseArray, long key); + method public static inline void forEach(androidx.collection.LongSparseArray, kotlin.jvm.functions.Function2 action); + method public static inline T getOrDefault(androidx.collection.LongSparseArray, long key, T defaultValue); + method public static inline T getOrElse(androidx.collection.LongSparseArray, long key, kotlin.jvm.functions.Function0 defaultValue); + method public static inline int getSize(androidx.collection.LongSparseArray); + method public static inline boolean isNotEmpty(androidx.collection.LongSparseArray); + method public static kotlin.collections.LongIterator keyIterator(androidx.collection.LongSparseArray); + method public static operator androidx.collection.LongSparseArray plus(androidx.collection.LongSparseArray, androidx.collection.LongSparseArray other); + method @Deprecated public static boolean remove(androidx.collection.LongSparseArray, long key, T value); + method public static inline operator void set(androidx.collection.LongSparseArray, long key, T value); + method public static java.util.Iterator valueIterator(androidx.collection.LongSparseArray); + } + + public class LruCache { + ctor public LruCache(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize); + method protected V? create(K key); + method public final int createCount(); + method protected void entryRemoved(boolean evicted, K key, V oldValue, V? newValue); + method public final void evictAll(); + method public final int evictionCount(); + method public final operator V? get(K key); + method public final int hitCount(); + method public final int maxSize(); + method public final int missCount(); + method public final V? put(K key, V value); + method public final int putCount(); + method public final V? remove(K key); + method public void resize(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize); + method public final int size(); + method protected int sizeOf(K key, V value); + method public final java.util.Map snapshot(); + method public void trimToSize(int maxSize); + } + + public final class LruCacheKt { + method public static inline androidx.collection.LruCache lruCache(int maxSize, optional kotlin.jvm.functions.Function2 sizeOf, optional kotlin.jvm.functions.Function1 create, optional kotlin.jvm.functions.Function4 onEntryRemoved); + } + + public final class MutableDoubleList extends androidx.collection.DoubleList { + ctor public MutableDoubleList(); + ctor public MutableDoubleList(optional int initialCapacity); + method public boolean add(double element); + method public void add(@IntRange(from=0L) int index, double element); + method public inline boolean addAll(androidx.collection.DoubleList elements); + method public inline boolean addAll(double[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.DoubleList elements); + method public boolean addAll(@IntRange(from=0L) int index, double[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.DoubleList elements); + method public inline operator void minusAssign(double element); + method public operator void minusAssign(double[] elements); + method public inline operator void plusAssign(androidx.collection.DoubleList elements); + method public inline operator void plusAssign(double element); + method public inline operator void plusAssign(double[] elements); + method public boolean remove(double element); + method public boolean removeAll(androidx.collection.DoubleList elements); + method public boolean removeAll(double[] elements); + method public double removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.DoubleList elements); + method public boolean retainAll(double[] elements); + method public operator double set(@IntRange(from=0L) int index, double element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableFloatFloatMap extends androidx.collection.FloatFloatMap { + ctor public MutableFloatFloatMap(); + ctor public MutableFloatFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatFloatMap from); + method public void put(float key, float value); + method public float put(float key, float value, float default); + method public void putAll(androidx.collection.FloatFloatMap from); + method public void remove(float key); + method public boolean remove(float key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(float key, float value); + method public int trim(); + } + + public final class MutableFloatIntMap extends androidx.collection.FloatIntMap { + ctor public MutableFloatIntMap(); + ctor public MutableFloatIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatIntMap from); + method public void put(float key, int value); + method public int put(float key, int value, int default); + method public void putAll(androidx.collection.FloatIntMap from); + method public void remove(float key); + method public boolean remove(float key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(float key, int value); + method public int trim(); + } + + public final class MutableFloatList extends androidx.collection.FloatList { + ctor public MutableFloatList(); + ctor public MutableFloatList(optional int initialCapacity); + method public boolean add(float element); + method public void add(@IntRange(from=0L) int index, float element); + method public inline boolean addAll(androidx.collection.FloatList elements); + method public inline boolean addAll(float[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.FloatList elements); + method public boolean addAll(@IntRange(from=0L) int index, float[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.FloatList elements); + method public inline operator void minusAssign(float element); + method public operator void minusAssign(float[] elements); + method public inline operator void plusAssign(androidx.collection.FloatList elements); + method public inline operator void plusAssign(float element); + method public inline operator void plusAssign(float[] elements); + method public boolean remove(float element); + method public boolean removeAll(androidx.collection.FloatList elements); + method public boolean removeAll(float[] elements); + method public float removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.FloatList elements); + method public boolean retainAll(float[] elements); + method public operator float set(@IntRange(from=0L) int index, float element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableFloatLongMap extends androidx.collection.FloatLongMap { + ctor public MutableFloatLongMap(); + ctor public MutableFloatLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatLongMap from); + method public void put(float key, long value); + method public long put(float key, long value, long default); + method public void putAll(androidx.collection.FloatLongMap from); + method public void remove(float key); + method public boolean remove(float key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(float key, long value); + method public int trim(); + } + + public final class MutableFloatObjectMap extends androidx.collection.FloatObjectMap { + ctor public MutableFloatObjectMap(); + ctor public MutableFloatObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(float key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.FloatList keys); + method public inline operator void minusAssign(androidx.collection.FloatSet keys); + method public inline operator void minusAssign(float key); + method public inline operator void minusAssign(float[] keys); + method public inline operator void plusAssign(androidx.collection.FloatObjectMap from); + method public V? put(float key, V value); + method public void putAll(androidx.collection.FloatObjectMap from); + method public V? remove(float key); + method public boolean remove(float key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal V? removeValueAt(int index); + method public operator void set(float key, V value); + method public int trim(); + } + + public final class MutableFloatSet extends androidx.collection.FloatSet { + ctor public MutableFloatSet(); + ctor public MutableFloatSet(optional int initialCapacity); + method public boolean add(float element); + method public boolean addAll(androidx.collection.FloatSet elements); + method public boolean addAll(float[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.FloatSet elements); + method public operator void minusAssign(float element); + method public operator void minusAssign(float[] elements); + method public operator void plusAssign(androidx.collection.FloatSet elements); + method public operator void plusAssign(float element); + method public operator void plusAssign(float[] elements); + method public boolean remove(float element); + method public boolean removeAll(androidx.collection.FloatSet elements); + method public boolean removeAll(float[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableIntFloatMap extends androidx.collection.IntFloatMap { + ctor public MutableIntFloatMap(); + ctor public MutableIntFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntFloatMap from); + method public void put(int key, float value); + method public float put(int key, float value, float default); + method public void putAll(androidx.collection.IntFloatMap from); + method public void remove(int key); + method public boolean remove(int key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(int key, float value); + method public int trim(); + } + + public final class MutableIntIntMap extends androidx.collection.IntIntMap { + ctor public MutableIntIntMap(); + ctor public MutableIntIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntIntMap from); + method public void put(int key, int value); + method public int put(int key, int value, int default); + method public void putAll(androidx.collection.IntIntMap from); + method public void remove(int key); + method public boolean remove(int key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(int key, int value); + method public int trim(); + } + + public final class MutableIntList extends androidx.collection.IntList { + ctor public MutableIntList(); + ctor public MutableIntList(optional int initialCapacity); + method public boolean add(int element); + method public void add(@IntRange(from=0L) int index, int element); + method public inline boolean addAll(androidx.collection.IntList elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.IntList elements); + method public boolean addAll(@IntRange(from=0L) int index, int[] elements); + method public inline boolean addAll(int[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.IntList elements); + method public inline operator void minusAssign(int element); + method public operator void minusAssign(int[] elements); + method public inline operator void plusAssign(androidx.collection.IntList elements); + method public inline operator void plusAssign(int element); + method public inline operator void plusAssign(int[] elements); + method public boolean remove(int element); + method public boolean removeAll(androidx.collection.IntList elements); + method public boolean removeAll(int[] elements); + method public int removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.IntList elements); + method public boolean retainAll(int[] elements); + method public operator int set(@IntRange(from=0L) int index, int element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableIntLongMap extends androidx.collection.IntLongMap { + ctor public MutableIntLongMap(); + ctor public MutableIntLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntLongMap from); + method public void put(int key, long value); + method public long put(int key, long value, long default); + method public void putAll(androidx.collection.IntLongMap from); + method public void remove(int key); + method public boolean remove(int key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(int key, long value); + method public int trim(); + } + + public final class MutableIntObjectMap extends androidx.collection.IntObjectMap { + ctor public MutableIntObjectMap(); + ctor public MutableIntObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(int key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.IntList keys); + method public inline operator void minusAssign(androidx.collection.IntSet keys); + method public inline operator void minusAssign(int key); + method public inline operator void minusAssign(int[] keys); + method public inline operator void plusAssign(androidx.collection.IntObjectMap from); + method public V? put(int key, V value); + method public void putAll(androidx.collection.IntObjectMap from); + method public V? remove(int key); + method public boolean remove(int key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal V? removeValueAt(int index); + method public operator void set(int key, V value); + method public int trim(); + } + + public final class MutableIntSet extends androidx.collection.IntSet { + ctor public MutableIntSet(); + ctor public MutableIntSet(optional int initialCapacity); + method public boolean add(int element); + method public boolean addAll(androidx.collection.IntSet elements); + method public boolean addAll(int[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.IntSet elements); + method public operator void minusAssign(int element); + method public operator void minusAssign(int[] elements); + method public operator void plusAssign(androidx.collection.IntSet elements); + method public operator void plusAssign(int element); + method public operator void plusAssign(int[] elements); + method public boolean remove(int element); + method public boolean removeAll(androidx.collection.IntSet elements); + method public boolean removeAll(int[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableLongFloatMap extends androidx.collection.LongFloatMap { + ctor public MutableLongFloatMap(); + ctor public MutableLongFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongFloatMap from); + method public void put(long key, float value); + method public float put(long key, float value, float default); + method public void putAll(androidx.collection.LongFloatMap from); + method public void remove(long key); + method public boolean remove(long key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(long key, float value); + method public int trim(); + } + + public final class MutableLongIntMap extends androidx.collection.LongIntMap { + ctor public MutableLongIntMap(); + ctor public MutableLongIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongIntMap from); + method public void put(long key, int value); + method public int put(long key, int value, int default); + method public void putAll(androidx.collection.LongIntMap from); + method public void remove(long key); + method public boolean remove(long key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(long key, int value); + method public int trim(); + } + + public final class MutableLongList extends androidx.collection.LongList { + ctor public MutableLongList(); + ctor public MutableLongList(optional int initialCapacity); + method public void add(@IntRange(from=0L) int index, long element); + method public boolean add(long element); + method public inline boolean addAll(androidx.collection.LongList elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.LongList elements); + method public boolean addAll(@IntRange(from=0L) int index, long[] elements); + method public inline boolean addAll(long[] elements); + method public void clear(); + method public void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.LongList elements); + method public inline operator void minusAssign(long element); + method public operator void minusAssign(long[] elements); + method public inline operator void plusAssign(androidx.collection.LongList elements); + method public inline operator void plusAssign(long element); + method public inline operator void plusAssign(long[] elements); + method public boolean remove(long element); + method public boolean removeAll(androidx.collection.LongList elements); + method public boolean removeAll(long[] elements); + method public long removeAt(@IntRange(from=0L) int index); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method public boolean retainAll(androidx.collection.LongList elements); + method public boolean retainAll(long[] elements); + method public operator long set(@IntRange(from=0L) int index, long element); + method public void sort(); + method public void sortDescending(); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableLongLongMap extends androidx.collection.LongLongMap { + ctor public MutableLongLongMap(); + ctor public MutableLongLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongLongMap from); + method public void put(long key, long value); + method public long put(long key, long value, long default); + method public void putAll(androidx.collection.LongLongMap from); + method public void remove(long key); + method public boolean remove(long key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(long key, long value); + method public int trim(); + } + + public final class MutableLongObjectMap extends androidx.collection.LongObjectMap { + ctor public MutableLongObjectMap(); + ctor public MutableLongObjectMap(optional int initialCapacity); + method public void clear(); + method public inline V getOrPut(long key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.LongList keys); + method public inline operator void minusAssign(androidx.collection.LongSet keys); + method public inline operator void minusAssign(long key); + method public inline operator void minusAssign(long[] keys); + method public inline operator void plusAssign(androidx.collection.LongObjectMap from); + method public V? put(long key, V value); + method public void putAll(androidx.collection.LongObjectMap from); + method public V? remove(long key); + method public boolean remove(long key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal V? removeValueAt(int index); + method public operator void set(long key, V value); + method public int trim(); + } + + public final class MutableLongSet extends androidx.collection.LongSet { + ctor public MutableLongSet(); + ctor public MutableLongSet(optional int initialCapacity); + method public boolean add(long element); + method public boolean addAll(androidx.collection.LongSet elements); + method public boolean addAll(long[] elements); + method public void clear(); + method public operator void minusAssign(androidx.collection.LongSet elements); + method public operator void minusAssign(long element); + method public operator void minusAssign(long[] elements); + method public operator void plusAssign(androidx.collection.LongSet elements); + method public operator void plusAssign(long element); + method public operator void plusAssign(long[] elements); + method public boolean remove(long element); + method public boolean removeAll(androidx.collection.LongSet elements); + method public boolean removeAll(long[] elements); + method @IntRange(from=0L) public int trim(); + } + + public final class MutableObjectFloatMap extends androidx.collection.ObjectFloatMap { + ctor public MutableObjectFloatMap(); + ctor public MutableObjectFloatMap(optional int initialCapacity); + method public void clear(); + method public inline float getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectFloatMap from); + method public void put(K key, float value); + method public float put(K key, float value, float default); + method public void putAll(androidx.collection.ObjectFloatMap from); + method public void remove(K key); + method public boolean remove(K key, float value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(K key, float value); + method public int trim(); + } + + public final class MutableObjectIntMap extends androidx.collection.ObjectIntMap { + ctor public MutableObjectIntMap(); + ctor public MutableObjectIntMap(optional int initialCapacity); + method public void clear(); + method public inline int getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectIntMap from); + method public void put(K key, int value); + method public int put(K key, int value, int default); + method public void putAll(androidx.collection.ObjectIntMap from); + method public void remove(K key); + method public boolean remove(K key, int value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(K key, int value); + method public int trim(); + } + + public final class MutableObjectList extends androidx.collection.ObjectList { + ctor public MutableObjectList(); + ctor public MutableObjectList(optional int initialCapacity); + method public boolean add(E element); + method public void add(@IntRange(from=0L) int index, E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.ObjectList elements); + method public boolean addAll(@IntRange(from=0L) int index, E[] elements); + method public boolean addAll(@IntRange(from=0L) int index, java.util.Collection elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(java.util.List elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.List asList(); + method public java.util.List asMutableList(); + method public void clear(); + method public inline void ensureCapacity(int capacity); + method public inline int getCapacity(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public inline operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(java.util.List elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public inline operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(java.util.List elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(java.util.List elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method public E removeAt(@IntRange(from=0L) int index); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end); + method @kotlin.PublishedApi internal void resizeStorage(int capacity, Object?[] oldContent); + method public boolean retainAll(androidx.collection.ObjectList elements); + method public boolean retainAll(E[] elements); + method public boolean retainAll(Iterable elements); + method public boolean retainAll(java.util.Collection elements); + method public boolean retainAll(kotlin.sequences.Sequence elements); + method public operator E set(@IntRange(from=0L) int index, E element); + method public void trim(optional int minCapacity); + property public final inline int capacity; + } + + public final class MutableObjectLongMap extends androidx.collection.ObjectLongMap { + ctor public MutableObjectLongMap(); + ctor public MutableObjectLongMap(optional int initialCapacity); + method public void clear(); + method public inline long getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ObjectLongMap from); + method public void put(K key, long value); + method public long put(K key, long value, long default); + method public void putAll(androidx.collection.ObjectLongMap from); + method public void remove(K key); + method public boolean remove(K key, long value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal void removeValueAt(int index); + method public operator void set(K key, long value); + method public int trim(); + } + + public final class MutableOrderedScatterSet extends androidx.collection.OrderedScatterSet { + ctor public MutableOrderedScatterSet(); + ctor public MutableOrderedScatterSet(optional int initialCapacity); + method public boolean add(E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.OrderedScatterSet elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.Set asMutableSet(); + method public void clear(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.OrderedScatterSet elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method @kotlin.PublishedApi internal void removeElementAt(int index); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public boolean retainAll(androidx.collection.OrderedScatterSet elements); + method public boolean retainAll(androidx.collection.ScatterSet elements); + method public boolean retainAll(java.util.Collection elements); + method public inline boolean retainAll(kotlin.jvm.functions.Function1 predicate); + method @IntRange(from=0L) public int trim(); + method public void trimToSize(int maxSize); + } + + public final class MutableScatterMap extends androidx.collection.ScatterMap { + ctor public MutableScatterMap(); + ctor public MutableScatterMap(optional int initialCapacity); + method public java.util.Map asMutableMap(); + method public void clear(); + method public inline V compute(K key, kotlin.jvm.functions.Function2 computeBlock); + method @kotlin.PublishedApi internal int findInsertIndex(K key); + method public inline V getOrPut(K key, kotlin.jvm.functions.Function0 defaultValue); + method public inline operator void minusAssign(androidx.collection.ObjectList keys); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public inline operator void plusAssign(androidx.collection.ScatterMap from); + method public inline operator void plusAssign(Iterable> pairs); + method public inline operator void plusAssign(java.util.Map from); + method public inline operator void plusAssign(kotlin.Pair pair); + method public inline operator void plusAssign(kotlin.Pair[] pairs); + method public inline operator void plusAssign(kotlin.sequences.Sequence> pairs); + method public V? put(K key, V value); + method public void putAll(androidx.collection.ScatterMap from); + method public void putAll(Iterable> pairs); + method public void putAll(java.util.Map from); + method public void putAll(kotlin.Pair[] pairs); + method public void putAll(kotlin.sequences.Sequence> pairs); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public inline void removeIf(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal V? removeValueAt(int index); + method public operator void set(K key, V value); + method public int trim(); + } + + public final class MutableScatterSet extends androidx.collection.ScatterSet { + ctor public MutableScatterSet(); + ctor public MutableScatterSet(optional int initialCapacity); + method public boolean add(E element); + method public boolean addAll(androidx.collection.ObjectList elements); + method public boolean addAll(androidx.collection.OrderedScatterSet elements); + method public boolean addAll(androidx.collection.ScatterSet elements); + method public boolean addAll(E[] elements); + method public boolean addAll(Iterable elements); + method public boolean addAll(kotlin.sequences.Sequence elements); + method public java.util.Set asMutableSet(); + method public void clear(); + method public operator void minusAssign(androidx.collection.ObjectList elements); + method public operator void minusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void minusAssign(androidx.collection.ScatterSet elements); + method public operator void minusAssign(E element); + method public operator void minusAssign(E[] elements); + method public operator void minusAssign(Iterable elements); + method public operator void minusAssign(kotlin.sequences.Sequence elements); + method public operator void plusAssign(androidx.collection.ObjectList elements); + method public operator void plusAssign(androidx.collection.OrderedScatterSet elements); + method public operator void plusAssign(androidx.collection.ScatterSet elements); + method public operator void plusAssign(E element); + method public operator void plusAssign(E[] elements); + method public operator void plusAssign(Iterable elements); + method public operator void plusAssign(kotlin.sequences.Sequence elements); + method public boolean remove(E element); + method public boolean removeAll(androidx.collection.ObjectList elements); + method public boolean removeAll(androidx.collection.OrderedScatterSet elements); + method public boolean removeAll(androidx.collection.ScatterSet elements); + method public boolean removeAll(E[] elements); + method public boolean removeAll(Iterable elements); + method public boolean removeAll(kotlin.sequences.Sequence elements); + method @kotlin.PublishedApi internal void removeElementAt(int index); + method public inline void removeIf(kotlin.jvm.functions.Function1 predicate); + method public boolean retainAll(androidx.collection.OrderedScatterSet elements); + method public boolean retainAll(androidx.collection.ScatterSet elements); + method public boolean retainAll(java.util.Collection elements); + method public boolean retainAll(kotlin.jvm.functions.Function1 predicate); + method @IntRange(from=0L) public int trim(); + } + + public abstract sealed class ObjectFloatMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(float value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(K key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator float get(K key); + method public final int getCapacity(); + method public final float getOrDefault(K key, float defaultValue); + method public final inline float getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final Object?[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final float[] values; + field @kotlin.PublishedApi internal Object?[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal float[] values; + } + + public final class ObjectFloatMapKt { + method public static inline androidx.collection.ObjectFloatMap buildObjectFloatMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectFloatMap buildObjectFloatMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectFloatMap emptyObjectFloatMap(); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4); + method public static androidx.collection.MutableObjectFloatMap mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5); + method public static androidx.collection.ObjectFloatMap objectFloatMap(); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4); + method public static androidx.collection.ObjectFloatMap objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5); + } + + public abstract sealed class ObjectIntMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(int value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(K key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator int get(K key); + method public final int getCapacity(); + method public final int getOrDefault(K key, int defaultValue); + method public final inline int getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final Object?[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final int[] values; + field @kotlin.PublishedApi internal Object?[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal int[] values; + } + + public final class ObjectIntMapKt { + method public static inline androidx.collection.ObjectIntMap buildObjectIntMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectIntMap buildObjectIntMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectIntMap emptyObjectIntMap(); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4); + method public static androidx.collection.MutableObjectIntMap mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5); + method public static androidx.collection.ObjectIntMap objectIntMap(); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4); + method public static androidx.collection.ObjectIntMap objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5); + } + + public abstract sealed class ObjectList { + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public abstract java.util.List asList(); + method public final operator boolean contains(E element); + method public final boolean containsAll(androidx.collection.ObjectList elements); + method public final boolean containsAll(E[] elements); + method public final boolean containsAll(Iterable elements); + method public final boolean containsAll(java.util.List elements); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E elementAt(@IntRange(from=0L) int index); + method public final inline E elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1 defaultValue); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline R fold(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline R foldRight(R initial, kotlin.jvm.functions.Function2 operation); + method public final inline R foldRightIndexed(R initial, kotlin.jvm.functions.Function3 operation); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachIndexed(kotlin.jvm.functions.Function2 block); + method public final inline void forEachReversed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2 block); + method public final operator E get(@IntRange(from=0L) int index); + method public final inline kotlin.ranges.IntRange getIndices(); + method @IntRange(from=-1L) public final inline int getLastIndex(); + method @IntRange(from=0L) public final int getSize(); + method public final int indexOf(E element); + method public final inline int indexOfFirst(kotlin.jvm.functions.Function1 predicate); + method public final inline int indexOfLast(kotlin.jvm.functions.Function1 predicate); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final E last(); + method public final inline E last(kotlin.jvm.functions.Function1 predicate); + method public final int lastIndexOf(E element); + method public final inline E? lastOrNull(); + method public final inline E? lastOrNull(kotlin.jvm.functions.Function1 predicate); + method public final boolean none(); + method public final inline boolean reversedAny(kotlin.jvm.functions.Function1 predicate); + property @kotlin.PublishedApi internal final int _size; + property @kotlin.PublishedApi internal final Object?[] content; + property public final inline kotlin.ranges.IntRange indices; + property @IntRange(from=-1L) public final inline int lastIndex; + property @IntRange(from=0L) public final int size; + field @kotlin.PublishedApi internal int _size; + field @kotlin.PublishedApi internal Object?[] content; + } + + public final class ObjectListKt { + method public static androidx.collection.ObjectList emptyObjectList(); + method public static inline androidx.collection.MutableObjectList mutableObjectListOf(); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1, E element2); + method public static androidx.collection.MutableObjectList mutableObjectListOf(E element1, E element2, E element3); + method public static inline androidx.collection.MutableObjectList mutableObjectListOf(E... elements); + method public static androidx.collection.ObjectList objectListOf(); + method public static androidx.collection.ObjectList objectListOf(E element1); + method public static androidx.collection.ObjectList objectListOf(E element1, E element2); + method public static androidx.collection.ObjectList objectListOf(E element1, E element2, E element3); + method public static androidx.collection.ObjectList objectListOf(E... elements); + } + + public abstract sealed class ObjectLongMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final inline operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(long value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method @kotlin.PublishedApi internal final int findKeyIndex(K key); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator long get(K key); + method public final int getCapacity(); + method public final long getOrDefault(K key, long defaultValue); + method public final inline long getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2 transform); + method public final inline String joinToString(kotlin.jvm.functions.Function2 transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final Object?[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final long[] values; + field @kotlin.PublishedApi internal Object?[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal long[] values; + } + + public final class ObjectLongMapKt { + method public static inline androidx.collection.ObjectLongMap buildObjectLongMap(int initialCapacity, kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static inline androidx.collection.ObjectLongMap buildObjectLongMap(kotlin.jvm.functions.Function1,kotlin.Unit> builderAction); + method public static androidx.collection.ObjectLongMap emptyObjectLongMap(); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4); + method public static androidx.collection.MutableObjectLongMap mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5); + method public static androidx.collection.ObjectLongMap objectLongMap(); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4); + method public static androidx.collection.ObjectLongMap objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5); + } + + public abstract sealed class OrderedScatterSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final java.util.Set asSet(); + method public final operator boolean contains(E element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method public final inline void forEachReverse(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final E last(); + method public final inline E last(kotlin.jvm.functions.Function1 predicate); + method public final inline E? lastOrNull(kotlin.jvm.functions.Function1 predicate); + method public final boolean none(); + method public final inline java.util.List toList(); + method @kotlin.PublishedApi internal final inline void unorderedForEach(kotlin.jvm.functions.Function1 block); + method @kotlin.PublishedApi internal final inline void unorderedForEachIndex(kotlin.jvm.functions.Function1 block); + property @IntRange(from=0L) public final int capacity; + property @kotlin.PublishedApi internal final Object?[] elements; + property @kotlin.PublishedApi internal final int head; + property @kotlin.PublishedApi internal final long[] metadata; + property @kotlin.PublishedApi internal final long[] nodes; + property @IntRange(from=0L) public final int size; + property @kotlin.PublishedApi internal final int tail; + field @kotlin.PublishedApi internal Object?[] elements; + field @kotlin.PublishedApi internal int head; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal long[] nodes; + field @kotlin.PublishedApi internal int tail; + } + + public final class OrderedScatterSetKt { + method public static androidx.collection.OrderedScatterSet emptyOrderedScatterSet(); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1, E element2); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.MutableOrderedScatterSet mutableOrderedScatterSetOf(E... elements); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1, E element2); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.OrderedScatterSet orderedScatterSetOf(E... elements); + } + + public abstract sealed class ScatterMap { + method public final inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public final java.util.Map asMap(); + method public final operator boolean contains(K key); + method public final boolean containsKey(K key); + method public final boolean containsValue(V value); + method public final int count(); + method public final inline int count(kotlin.jvm.functions.Function2 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public final inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public final inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public final operator V? get(K key); + method public final int getCapacity(); + method public final V getOrDefault(K key, V defaultValue); + method public final inline V getOrElse(K key, kotlin.jvm.functions.Function0 defaultValue); + method public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function2? transform); + method public final boolean none(); + property public final int capacity; + property @kotlin.PublishedApi internal final Object?[] keys; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final Object?[] values; + field @kotlin.PublishedApi internal Object?[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal Object?[] values; + } + + public final class ScatterMapKt { + method public static androidx.collection.ScatterMap emptyScatterMap(); + method @kotlin.PublishedApi internal static inline boolean isFull(long value); + method @kotlin.PublishedApi internal static inline int lowestBitSet(long); + method @kotlin.PublishedApi internal static inline long maskEmptyOrDeleted(long); + method @kotlin.PublishedApi internal static inline long match(long, int m); + method public static androidx.collection.MutableScatterMap mutableScatterMapOf(); + method public static androidx.collection.MutableScatterMap mutableScatterMapOf(kotlin.Pair... pairs); + method @kotlin.PublishedApi internal static inline long readRawMetadata(long[] data, int offset); + property @kotlin.PublishedApi internal static final long BitmaskLsb; + property @kotlin.PublishedApi internal static final long BitmaskMsb; + property @kotlin.PublishedApi internal static final long Sentinel; + field @kotlin.PublishedApi internal static final long BitmaskLsb = 72340172838076673L; // 0x101010101010101L + field @kotlin.PublishedApi internal static final long BitmaskMsb = -9187201950435737472L; // 0x8080808080808080L + field @kotlin.PublishedApi internal static final long Sentinel = 255L; // 0xffL + } + + public abstract sealed class ScatterSet { + method public final inline boolean all(kotlin.jvm.functions.Function1 predicate); + method public final boolean any(); + method public final inline boolean any(kotlin.jvm.functions.Function1 predicate); + method public final java.util.Set asSet(); + method public final operator boolean contains(E element); + method @IntRange(from=0L) public final int count(); + method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1 predicate); + method public final E first(); + method public final inline E first(kotlin.jvm.functions.Function1 predicate); + method public final inline E? firstOrNull(kotlin.jvm.functions.Function1 predicate); + method public final inline void forEach(kotlin.jvm.functions.Function1 block); + method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1 block); + method @IntRange(from=0L) public final int getCapacity(); + method @IntRange(from=0L) public final int getSize(); + method public final boolean isEmpty(); + method public final boolean isNotEmpty(); + method public final String joinToString(); + method public final String joinToString(optional CharSequence separator); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated); + method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1? transform); + method public final boolean none(); + property @IntRange(from=0L) public final int capacity; + property @kotlin.PublishedApi internal final Object?[] elements; + property @kotlin.PublishedApi internal final long[] metadata; + property @IntRange(from=0L) public final int size; + field @kotlin.PublishedApi internal Object?[] elements; + field @kotlin.PublishedApi internal long[] metadata; + } + + public final class ScatterSetKt { + method public static androidx.collection.ScatterSet emptyScatterSet(); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1, E element2); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.MutableScatterSet mutableScatterSetOf(E... elements); + method public static androidx.collection.ScatterSet scatterSetOf(); + method public static androidx.collection.ScatterSet scatterSetOf(E element1); + method public static androidx.collection.ScatterSet scatterSetOf(E element1, E element2); + method public static androidx.collection.ScatterSet scatterSetOf(E element1, E element2, E element3); + method public static androidx.collection.ScatterSet scatterSetOf(E... elements); + } + + public final class SieveCache { + ctor public SieveCache(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize, optional @IntRange(from=0L, to=androidx.collection.SieveCacheKt.MaxSize) int initialCapacity, optional kotlin.jvm.functions.Function2 sizeOf, optional kotlin.jvm.functions.Function1 createValueFromKey, optional kotlin.jvm.functions.Function4 onEntryRemoved); + method public inline boolean all(kotlin.jvm.functions.Function2 predicate); + method public boolean any(); + method public inline boolean any(kotlin.jvm.functions.Function2 predicate); + method public operator boolean contains(K key); + method public boolean containsKey(K key); + method public boolean containsValue(V value); + method public int count(); + method public inline int count(kotlin.jvm.functions.Function2 predicate); + method public void evictAll(); + method public inline void forEach(kotlin.jvm.functions.Function2 block); + method @kotlin.PublishedApi internal inline void forEachIndexed(kotlin.jvm.functions.Function1 block); + method public inline void forEachKey(kotlin.jvm.functions.Function1 block); + method public inline void forEachValue(kotlin.jvm.functions.Function1 block); + method public operator V? get(K key); + method public int getCapacity(); + method public int getCount(); + method public int getMaxSize(); + method public int getSize(); + method public boolean isEmpty(); + method public boolean isNotEmpty(); + method public inline operator void minusAssign(androidx.collection.ObjectList keys); + method public inline operator void minusAssign(androidx.collection.ScatterSet keys); + method public inline operator void minusAssign(Iterable keys); + method public inline operator void minusAssign(K key); + method public inline operator void minusAssign(K[] keys); + method public inline operator void minusAssign(kotlin.sequences.Sequence keys); + method public boolean none(); + method public inline operator void plusAssign(androidx.collection.ScatterMap from); + method public inline operator void plusAssign(androidx.collection.SieveCache from); + method public inline operator void plusAssign(Iterable> pairs); + method public inline operator void plusAssign(java.util.Map from); + method public inline operator void plusAssign(kotlin.Pair pair); + method public inline operator void plusAssign(kotlin.Pair[] pairs); + method public inline operator void plusAssign(kotlin.sequences.Sequence> pairs); + method public V? put(K key, V value); + method public void putAll(androidx.collection.ScatterMap from); + method public void putAll(androidx.collection.SieveCache from); + method public void putAll(Iterable> pairs); + method public void putAll(java.util.Map from); + method public void putAll(kotlin.Pair[] pairs); + method public void putAll(kotlin.sequences.Sequence> pairs); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public void removeIf(kotlin.jvm.functions.Function2 predicate); + method public void resize(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize); + method public inline operator void set(K key, V value); + method public void trimToSize(int maxSize); + property public final int capacity; + property public final int count; + property @kotlin.PublishedApi internal final Object?[] keys; + property public final int maxSize; + property @kotlin.PublishedApi internal final long[] metadata; + property public final int size; + property @kotlin.PublishedApi internal final Object?[] values; + field @kotlin.PublishedApi internal Object?[] keys; + field @kotlin.PublishedApi internal long[] metadata; + field @kotlin.PublishedApi internal Object?[] values; + } + + public final class SieveCacheKt { + property @kotlin.PublishedApi internal static final int NodeInvalidLink; + property @kotlin.PublishedApi internal static final long NodeLinkMask; + field @kotlin.PublishedApi internal static final int NodeInvalidLink = 2147483647; // 0x7fffffff + field @kotlin.PublishedApi internal static final long NodeLinkMask = 2147483647L; // 0x7fffffffL + } + + public class SimpleArrayMap { + ctor public SimpleArrayMap(); + ctor public SimpleArrayMap(androidx.collection.SimpleArrayMap? map); + ctor public SimpleArrayMap(optional int capacity); + method public void clear(); + method public boolean containsKey(K key); + method public boolean containsValue(V value); + method public void ensureCapacity(int minimumCapacity); + method public operator V? get(K key); + method public V getOrDefault(Object? key, V defaultValue); + method public int indexOfKey(K key); + method public boolean isEmpty(); + method public K keyAt(int index); + method public V? put(K key, V value); + method public void putAll(androidx.collection.SimpleArrayMap map); + method public V? putIfAbsent(K key, V value); + method public V? remove(K key); + method public boolean remove(K key, V value); + method public V removeAt(int index); + method public V? replace(K key, V value); + method public boolean replace(K key, V oldValue, V newValue); + method public V setValueAt(int index, V value); + method public int size(); + method public V valueAt(int index); + } + + public class SparseArrayCompat implements java.lang.Cloneable { + ctor public SparseArrayCompat(); + ctor public SparseArrayCompat(optional int initialCapacity); + method public void append(int key, E value); + method public void clear(); + method public androidx.collection.SparseArrayCompat clone(); + method public boolean containsKey(int key); + method public boolean containsValue(E value); + method @Deprecated public void delete(int key); + method public operator E? get(int key); + method public E get(int key, E defaultValue); + method public final boolean getIsEmpty(); + method public int indexOfKey(int key); + method public int indexOfValue(E value); + method public boolean isEmpty(); + method public int keyAt(int index); + method public void put(int key, E value); + method public void putAll(androidx.collection.SparseArrayCompat other); + method public E? putIfAbsent(int key, E value); + method public void remove(int key); + method public boolean remove(int key, Object? value); + method public void removeAt(int index); + method public void removeAtRange(int index, int size); + method public E? replace(int key, E value); + method public boolean replace(int key, E oldValue, E newValue); + method public void setValueAt(int index, E value); + method public int size(); + method public E valueAt(int index); + property public final boolean isEmpty; + } + + public final class SparseArrayKt { + method public static inline operator boolean contains(androidx.collection.SparseArrayCompat, int key); + method public static inline void forEach(androidx.collection.SparseArrayCompat, kotlin.jvm.functions.Function2 action); + method public static inline T getOrDefault(androidx.collection.SparseArrayCompat, int key, T defaultValue); + method public static inline T getOrElse(androidx.collection.SparseArrayCompat, int key, kotlin.jvm.functions.Function0 defaultValue); + method public static inline int getSize(androidx.collection.SparseArrayCompat); + method public static inline boolean isNotEmpty(androidx.collection.SparseArrayCompat); + method public static kotlin.collections.IntIterator keyIterator(androidx.collection.SparseArrayCompat); + method public static operator androidx.collection.SparseArrayCompat plus(androidx.collection.SparseArrayCompat, androidx.collection.SparseArrayCompat other); + method @Deprecated public static boolean remove(androidx.collection.SparseArrayCompat, int key, T value); + method public static inline operator void set(androidx.collection.SparseArrayCompat, int key, T value); + method public static java.util.Iterator valueIterator(androidx.collection.SparseArrayCompat); + } + +} + +package androidx.collection.internal { + + public final class PackingHelpers_jvmKt { + method @kotlin.PublishedApi internal static inline float floatFromBits(int bits); + } + + public final class RuntimeHelpersKt { + method @kotlin.PublishedApi internal static Void throwNoSuchElementExceptionForInline(String message); + } + +} + diff --git a/collection/collection/bcv/native/current.txt b/collection/collection/bcv/native/current.txt index b47bdced9ee09..2073bfee980d7 100644 --- a/collection/collection/bcv/native/current.txt +++ b/collection/collection/bcv/native/current.txt @@ -982,8 +982,6 @@ open class <#A: kotlin/Any?> androidx.collection/SparseArrayCompat { // androidx } sealed class <#A: kotlin/Any?, #B: kotlin/Any?> androidx.collection/ScatterMap { // androidx.collection/ScatterMap|null[0] - constructor () // androidx.collection/ScatterMap.|(){}[0] - final val capacity // androidx.collection/ScatterMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/ScatterMap.capacity.|(){}[0] final val size // androidx.collection/ScatterMap.size|{}size[0] @@ -1025,8 +1023,6 @@ sealed class <#A: kotlin/Any?, #B: kotlin/Any?> androidx.collection/ScatterMap { } sealed class <#A: kotlin/Any?> androidx.collection/FloatObjectMap { // androidx.collection/FloatObjectMap|null[0] - constructor () // androidx.collection/FloatObjectMap.|(){}[0] - final val capacity // androidx.collection/FloatObjectMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/FloatObjectMap.capacity.|(){}[0] final val size // androidx.collection/FloatObjectMap.size|{}size[0] @@ -1068,8 +1064,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/FloatObjectMap { // androidx. } sealed class <#A: kotlin/Any?> androidx.collection/IntObjectMap { // androidx.collection/IntObjectMap|null[0] - constructor () // androidx.collection/IntObjectMap.|(){}[0] - final val capacity // androidx.collection/IntObjectMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/IntObjectMap.capacity.|(){}[0] final val size // androidx.collection/IntObjectMap.size|{}size[0] @@ -1111,8 +1105,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/IntObjectMap { // androidx.co } sealed class <#A: kotlin/Any?> androidx.collection/LongObjectMap { // androidx.collection/LongObjectMap|null[0] - constructor () // androidx.collection/LongObjectMap.|(){}[0] - final val capacity // androidx.collection/LongObjectMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/LongObjectMap.capacity.|(){}[0] final val size // androidx.collection/LongObjectMap.size|{}size[0] @@ -1154,8 +1146,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/LongObjectMap { // androidx.c } sealed class <#A: kotlin/Any?> androidx.collection/ObjectFloatMap { // androidx.collection/ObjectFloatMap|null[0] - constructor () // androidx.collection/ObjectFloatMap.|(){}[0] - final val capacity // androidx.collection/ObjectFloatMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/ObjectFloatMap.capacity.|(){}[0] final val size // androidx.collection/ObjectFloatMap.size|{}size[0] @@ -1198,8 +1188,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/ObjectFloatMap { // androidx. } sealed class <#A: kotlin/Any?> androidx.collection/ObjectIntMap { // androidx.collection/ObjectIntMap|null[0] - constructor () // androidx.collection/ObjectIntMap.|(){}[0] - final val capacity // androidx.collection/ObjectIntMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/ObjectIntMap.capacity.|(){}[0] final val size // androidx.collection/ObjectIntMap.size|{}size[0] @@ -1242,8 +1230,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/ObjectIntMap { // androidx.co } sealed class <#A: kotlin/Any?> androidx.collection/ObjectList { // androidx.collection/ObjectList|null[0] - constructor (kotlin/Int) // androidx.collection/ObjectList.|(kotlin.Int){}[0] - final val indices // androidx.collection/ObjectList.indices|{}indices[0] final inline fun (): kotlin.ranges/IntRange // androidx.collection/ObjectList.indices.|(){}[0] final val lastIndex // androidx.collection/ObjectList.lastIndex|{}lastIndex[0] @@ -1302,8 +1288,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/ObjectList { // androidx.coll } sealed class <#A: kotlin/Any?> androidx.collection/ObjectLongMap { // androidx.collection/ObjectLongMap|null[0] - constructor () // androidx.collection/ObjectLongMap.|(){}[0] - final val capacity // androidx.collection/ObjectLongMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/ObjectLongMap.capacity.|(){}[0] final val size // androidx.collection/ObjectLongMap.size|{}size[0] @@ -1346,8 +1330,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/ObjectLongMap { // androidx.c } sealed class <#A: kotlin/Any?> androidx.collection/OrderedScatterSet { // androidx.collection/OrderedScatterSet|null[0] - constructor () // androidx.collection/OrderedScatterSet.|(){}[0] - final val capacity // androidx.collection/OrderedScatterSet.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/OrderedScatterSet.capacity.|(){}[0] final val size // androidx.collection/OrderedScatterSet.size|{}size[0] @@ -1397,8 +1379,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/OrderedScatterSet { // androi } sealed class <#A: kotlin/Any?> androidx.collection/ScatterSet { // androidx.collection/ScatterSet|null[0] - constructor () // androidx.collection/ScatterSet.|(){}[0] - final val capacity // androidx.collection/ScatterSet.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/ScatterSet.capacity.|(){}[0] final val size // androidx.collection/ScatterSet.size|{}size[0] @@ -1433,8 +1413,6 @@ sealed class <#A: kotlin/Any?> androidx.collection/ScatterSet { // androidx.coll } sealed class androidx.collection/DoubleList { // androidx.collection/DoubleList|null[0] - constructor (kotlin/Int) // androidx.collection/DoubleList.|(kotlin.Int){}[0] - final val indices // androidx.collection/DoubleList.indices|{}indices[0] final inline fun (): kotlin.ranges/IntRange // androidx.collection/DoubleList.indices.|(){}[0] final val lastIndex // androidx.collection/DoubleList.lastIndex|{}lastIndex[0] @@ -1487,8 +1465,6 @@ sealed class androidx.collection/DoubleList { // androidx.collection/DoubleList| } sealed class androidx.collection/FloatFloatMap { // androidx.collection/FloatFloatMap|null[0] - constructor () // androidx.collection/FloatFloatMap.|(){}[0] - final val capacity // androidx.collection/FloatFloatMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/FloatFloatMap.capacity.|(){}[0] final val size // androidx.collection/FloatFloatMap.size|{}size[0] @@ -1531,8 +1507,6 @@ sealed class androidx.collection/FloatFloatMap { // androidx.collection/FloatFlo } sealed class androidx.collection/FloatIntMap { // androidx.collection/FloatIntMap|null[0] - constructor () // androidx.collection/FloatIntMap.|(){}[0] - final val capacity // androidx.collection/FloatIntMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/FloatIntMap.capacity.|(){}[0] final val size // androidx.collection/FloatIntMap.size|{}size[0] @@ -1575,8 +1549,6 @@ sealed class androidx.collection/FloatIntMap { // androidx.collection/FloatIntMa } sealed class androidx.collection/FloatList { // androidx.collection/FloatList|null[0] - constructor (kotlin/Int) // androidx.collection/FloatList.|(kotlin.Int){}[0] - final val indices // androidx.collection/FloatList.indices|{}indices[0] final inline fun (): kotlin.ranges/IntRange // androidx.collection/FloatList.indices.|(){}[0] final val lastIndex // androidx.collection/FloatList.lastIndex|{}lastIndex[0] @@ -1629,8 +1601,6 @@ sealed class androidx.collection/FloatList { // androidx.collection/FloatList|nu } sealed class androidx.collection/FloatLongMap { // androidx.collection/FloatLongMap|null[0] - constructor () // androidx.collection/FloatLongMap.|(){}[0] - final val capacity // androidx.collection/FloatLongMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/FloatLongMap.capacity.|(){}[0] final val size // androidx.collection/FloatLongMap.size|{}size[0] @@ -1673,8 +1643,6 @@ sealed class androidx.collection/FloatLongMap { // androidx.collection/FloatLong } sealed class androidx.collection/FloatSet { // androidx.collection/FloatSet|null[0] - constructor () // androidx.collection/FloatSet.|(){}[0] - final val capacity // androidx.collection/FloatSet.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/FloatSet.capacity.|(){}[0] final val size // androidx.collection/FloatSet.size|{}size[0] @@ -1708,8 +1676,6 @@ sealed class androidx.collection/FloatSet { // androidx.collection/FloatSet|null } sealed class androidx.collection/IntFloatMap { // androidx.collection/IntFloatMap|null[0] - constructor () // androidx.collection/IntFloatMap.|(){}[0] - final val capacity // androidx.collection/IntFloatMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/IntFloatMap.capacity.|(){}[0] final val size // androidx.collection/IntFloatMap.size|{}size[0] @@ -1752,8 +1718,6 @@ sealed class androidx.collection/IntFloatMap { // androidx.collection/IntFloatMa } sealed class androidx.collection/IntIntMap { // androidx.collection/IntIntMap|null[0] - constructor () // androidx.collection/IntIntMap.|(){}[0] - final val capacity // androidx.collection/IntIntMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/IntIntMap.capacity.|(){}[0] final val size // androidx.collection/IntIntMap.size|{}size[0] @@ -1796,8 +1760,6 @@ sealed class androidx.collection/IntIntMap { // androidx.collection/IntIntMap|nu } sealed class androidx.collection/IntList { // androidx.collection/IntList|null[0] - constructor (kotlin/Int) // androidx.collection/IntList.|(kotlin.Int){}[0] - final val indices // androidx.collection/IntList.indices|{}indices[0] final inline fun (): kotlin.ranges/IntRange // androidx.collection/IntList.indices.|(){}[0] final val lastIndex // androidx.collection/IntList.lastIndex|{}lastIndex[0] @@ -1850,8 +1812,6 @@ sealed class androidx.collection/IntList { // androidx.collection/IntList|null[0 } sealed class androidx.collection/IntLongMap { // androidx.collection/IntLongMap|null[0] - constructor () // androidx.collection/IntLongMap.|(){}[0] - final val capacity // androidx.collection/IntLongMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/IntLongMap.capacity.|(){}[0] final val size // androidx.collection/IntLongMap.size|{}size[0] @@ -1894,8 +1854,6 @@ sealed class androidx.collection/IntLongMap { // androidx.collection/IntLongMap| } sealed class androidx.collection/IntSet { // androidx.collection/IntSet|null[0] - constructor () // androidx.collection/IntSet.|(){}[0] - final val capacity // androidx.collection/IntSet.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/IntSet.capacity.|(){}[0] final val size // androidx.collection/IntSet.size|{}size[0] @@ -1929,8 +1887,6 @@ sealed class androidx.collection/IntSet { // androidx.collection/IntSet|null[0] } sealed class androidx.collection/LongFloatMap { // androidx.collection/LongFloatMap|null[0] - constructor () // androidx.collection/LongFloatMap.|(){}[0] - final val capacity // androidx.collection/LongFloatMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/LongFloatMap.capacity.|(){}[0] final val size // androidx.collection/LongFloatMap.size|{}size[0] @@ -1973,8 +1929,6 @@ sealed class androidx.collection/LongFloatMap { // androidx.collection/LongFloat } sealed class androidx.collection/LongIntMap { // androidx.collection/LongIntMap|null[0] - constructor () // androidx.collection/LongIntMap.|(){}[0] - final val capacity // androidx.collection/LongIntMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/LongIntMap.capacity.|(){}[0] final val size // androidx.collection/LongIntMap.size|{}size[0] @@ -2017,8 +1971,6 @@ sealed class androidx.collection/LongIntMap { // androidx.collection/LongIntMap| } sealed class androidx.collection/LongList { // androidx.collection/LongList|null[0] - constructor (kotlin/Int) // androidx.collection/LongList.|(kotlin.Int){}[0] - final val indices // androidx.collection/LongList.indices|{}indices[0] final inline fun (): kotlin.ranges/IntRange // androidx.collection/LongList.indices.|(){}[0] final val lastIndex // androidx.collection/LongList.lastIndex|{}lastIndex[0] @@ -2071,8 +2023,6 @@ sealed class androidx.collection/LongList { // androidx.collection/LongList|null } sealed class androidx.collection/LongLongMap { // androidx.collection/LongLongMap|null[0] - constructor () // androidx.collection/LongLongMap.|(){}[0] - final val capacity // androidx.collection/LongLongMap.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/LongLongMap.capacity.|(){}[0] final val size // androidx.collection/LongLongMap.size|{}size[0] @@ -2115,8 +2065,6 @@ sealed class androidx.collection/LongLongMap { // androidx.collection/LongLongMa } sealed class androidx.collection/LongSet { // androidx.collection/LongSet|null[0] - constructor () // androidx.collection/LongSet.|(){}[0] - final val capacity // androidx.collection/LongSet.capacity|{}capacity[0] final fun (): kotlin/Int // androidx.collection/LongSet.capacity.|(){}[0] final val size // androidx.collection/LongSet.size|{}size[0] diff --git a/collection/collection/build.gradle b/collection/collection/build.gradle index b9a19626061f6..25b2a9d1daa39 100644 --- a/collection/collection/build.gradle +++ b/collection/collection/build.gradle @@ -66,7 +66,7 @@ kotlin { commonMain { dependencies { api(libs.kotlinStdlib) - implementation(project(":annotation:annotation")) + implementation("org.jetbrains.compose.annotation-internal:annotation:1.7.1") implementation(libs.atomicFu) } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatMap.kt index 9ef4cff02a28c..68e2d83443554 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatMap.kt @@ -539,7 +539,8 @@ public sealed class FloatFloatMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatPair.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatPair.kt index eeb89fed95d4a..9ee9c3e1f830e 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatPair.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatFloatPair.kt @@ -28,6 +28,7 @@ import kotlin.jvm.JvmInline * from Java code. Java developers can get the same functionality by using [Pair] or by constructing * a custom implementation using Float parameters directly (see [LongLongPair] for an example). */ +@Suppress("ValueClassDefinition") @JvmInline public value class FloatFloatPair internal constructor( diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatIntMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatIntMap.kt index 8d5f5476ad9fe..f8776569a0938 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatIntMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatIntMap.kt @@ -537,7 +537,8 @@ public sealed class FloatIntMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatLongMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatLongMap.kt index 5685c126ec5d5..58837c375292b 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/FloatLongMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/FloatLongMap.kt @@ -539,7 +539,8 @@ public sealed class FloatLongMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/IntFloatMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/IntFloatMap.kt index a1255ecada020..67429abd93037 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/IntFloatMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/IntFloatMap.kt @@ -537,7 +537,8 @@ public sealed class IntFloatMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntMap.kt index 6b913ad94cacd..cbfb9485326f7 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntMap.kt @@ -537,7 +537,8 @@ public sealed class IntIntMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntPair.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntPair.kt index 2d5bb2c5688fd..5faf8b4ffbfaf 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntPair.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/IntIntPair.kt @@ -27,6 +27,7 @@ import kotlin.jvm.JvmInline * from Java code. Java developers can get the same functionality by using [Pair] or by constructing * a custom implementation using Int parameters directly (see [LongLongPair] for an example). */ +@Suppress("ValueClassDefinition") @JvmInline public value class IntIntPair internal constructor( diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/IntLongMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/IntLongMap.kt index 87acb050edc04..104b8f99b64e6 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/IntLongMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/IntLongMap.kt @@ -537,7 +537,8 @@ public sealed class IntLongMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/LongFloatMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/LongFloatMap.kt index 16d6b2334e905..d117e48f73f42 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/LongFloatMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/LongFloatMap.kt @@ -539,7 +539,8 @@ public sealed class LongFloatMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/LongIntMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/LongIntMap.kt index cefe00952b682..813c95e00cf5a 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/LongIntMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/LongIntMap.kt @@ -537,7 +537,8 @@ public sealed class LongIntMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/LongLongMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/LongLongMap.kt index 5ed07fa526b83..add43b9f7a807 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/LongLongMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/LongLongMap.kt @@ -537,7 +537,8 @@ public sealed class LongLongMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectFloatMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectFloatMap.kt index c555feda2d8ad..9e7af10ff232c 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectFloatMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectFloatMap.kt @@ -547,7 +547,8 @@ public sealed class ObjectFloatMap { @Suppress("UNCHECKED_CAST") val o = other as ObjectFloatMap forEach { key, value -> - if (value != o[key]) { + val index = o.findKeyIndex(key) + if (index < 0 || value != o.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectIntMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectIntMap.kt index 2dba86bd97d7c..24332ee809d71 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectIntMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectIntMap.kt @@ -547,7 +547,8 @@ public sealed class ObjectIntMap { @Suppress("UNCHECKED_CAST") val o = other as ObjectIntMap forEach { key, value -> - if (value != o[key]) { + val index = o.findKeyIndex(key) + if (index < 0 || value != o.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectLongMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectLongMap.kt index 9077f59d04920..d106b56db389e 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectLongMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/ObjectLongMap.kt @@ -547,7 +547,8 @@ public sealed class ObjectLongMap { @Suppress("UNCHECKED_CAST") val o = other as ObjectLongMap forEach { key, value -> - if (value != o[key]) { + val index = o.findKeyIndex(key) + if (index < 0 || value != o.values[index]) { return false } } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/OrderedScatterSet.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/OrderedScatterSet.kt index f0e85dd02cc18..9921db294ebe6 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/OrderedScatterSet.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/OrderedScatterSet.kt @@ -547,32 +547,7 @@ public sealed class OrderedScatterSet { * possible, the semantics of [Set] may require the allocation of temporary objects for access * and iteration. */ - public fun asSet(): Set = SetWrapper() - - internal open inner class SetWrapper : Set { - override val size: Int - get() = this@OrderedScatterSet._size - - override fun containsAll(elements: Collection): Boolean { - elements.forEach { element -> - if (!this@OrderedScatterSet.contains(element)) { - return false - } - } - return true - } - - @Suppress("KotlinOperator") - override fun contains(element: E): Boolean { - return this@OrderedScatterSet.contains(element) - } - - override fun isEmpty(): Boolean = this@OrderedScatterSet.isEmpty() - - override fun iterator(): Iterator { - return iterator { this@OrderedScatterSet.forEach { element -> yield(element) } } - } - } + public fun asSet(): Set = OrderedSetWrapper(this) } /** @@ -1452,46 +1427,84 @@ public class MutableOrderedScatterSet(initialCapacity: Int = DefaultScatterCa * this method tries to be as efficient as possible, the semantics of [MutableSet] may require * the allocation of temporary objects for access and iteration. */ - public fun asMutableSet(): MutableSet = MutableSetWrapper() - - private inner class MutableSetWrapper : SetWrapper(), MutableSet { - override fun add(element: E): Boolean = this@MutableOrderedScatterSet.add(element) + public fun asMutableSet(): MutableSet = MutableOrderedSetWrapper(this) +} - override fun addAll(elements: Collection): Boolean = - this@MutableOrderedScatterSet.addAll(elements) +private open class OrderedSetWrapper(private val parent: OrderedScatterSet) : Set { + override val size: Int + get() = parent._size - override fun clear() { - this@MutableOrderedScatterSet.clear() + override fun containsAll(elements: Collection): Boolean { + elements.forEach { element -> + if (!parent.contains(element)) { + return false + } } + return true + } - override fun iterator(): MutableIterator = - object : MutableIterator { - var current = -1 - val iterator = iterator { - this@MutableOrderedScatterSet.forEachIndex { index -> - current = index - @Suppress("UNCHECKED_CAST") yield(elements[index] as E) - } + @Suppress("KotlinOperator") + override fun contains(element: E): Boolean { + return parent.contains(element) + } + + override fun isEmpty(): Boolean = parent.isEmpty() + + override fun iterator(): Iterator { + return iterator { parent.forEach { element -> yield(element) } } + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other == null || this::class != other::class) return false + + other as OrderedSetWrapper<*> + + return parent == other.parent + } + + override fun hashCode(): Int { + return parent.hashCode() + } + + override fun toString(): String = parent.toString() +} + +private class MutableOrderedSetWrapper(private val parent: MutableOrderedScatterSet) : + OrderedSetWrapper(parent), MutableSet { + override fun add(element: E): Boolean = parent.add(element) + + override fun addAll(elements: Collection): Boolean = parent.addAll(elements) + + override fun clear() { + parent.clear() + } + + override fun iterator(): MutableIterator = + object : MutableIterator { + var current = -1 + val iterator = iterator { + parent.forEachIndex { index -> + current = index + @Suppress("UNCHECKED_CAST") yield(parent.elements[index] as E) } + } - override fun hasNext(): Boolean = iterator.hasNext() + override fun hasNext(): Boolean = iterator.hasNext() - override fun next(): E = iterator.next() + override fun next(): E = iterator.next() - override fun remove() { - if (current != -1) { - this@MutableOrderedScatterSet.removeElementAt(current) - current = -1 - } + override fun remove() { + if (current != -1) { + parent.removeElementAt(current) + current = -1 } } + } - override fun remove(element: E): Boolean = this@MutableOrderedScatterSet.remove(element) + override fun remove(element: E): Boolean = parent.remove(element) - override fun retainAll(elements: Collection): Boolean = - this@MutableOrderedScatterSet.retainAll(elements) + override fun retainAll(elements: Collection): Boolean = parent.retainAll(elements) - override fun removeAll(elements: Collection): Boolean = - this@MutableOrderedScatterSet.removeAll(elements) - } + override fun removeAll(elements: Collection): Boolean = parent.removeAll(elements) } diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterMap.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterMap.kt index 9d756dc1ac344..6741c941c8ccf 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterMap.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterMap.kt @@ -1156,15 +1156,6 @@ internal inline fun convertMetadataForCleanup(metadata: LongArray, capacity: Int metadata[lastIndex] = metadata[0] } -internal fun findEmptySlot(metadata: LongArray, start: Int, end: Int): Int { - for (i in start until end) { - if (readRawMetadata(metadata, i) == Empty) { - return i - } - } - return -1 -} - /** * Returns the hash code of [k]. The hash spreads low bits to to minimize collisions in high 25-bits * that are used for probing. @@ -1490,6 +1481,19 @@ private open class MapWrapper(private val parent: ScatterMap) : Map< override fun containsValue(value: V): Boolean = parent.containsValue(value) override fun containsKey(key: K): Boolean = parent.containsKey(key) + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other == null || this::class != other::class) return false + + other as MapWrapper<*, *> + + return parent == other.parent + } + + override fun hashCode(): Int = parent.hashCode() + + override fun toString(): String = parent.toString() } private class MutableMapEntry( diff --git a/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterSet.kt b/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterSet.kt index a6903f814ab56..aacbd4ddea147 100644 --- a/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterSet.kt +++ b/collection/collection/src/commonMain/kotlin/androidx/collection/ScatterSet.kt @@ -425,32 +425,7 @@ public sealed class ScatterSet { * [Set] implementation returned by this method tries to be as efficient as possible, the * semantics of [Set] may require the allocation of temporary objects for access and iteration. */ - public fun asSet(): Set = SetWrapper() - - internal open inner class SetWrapper : Set { - override val size: Int - get() = this@ScatterSet._size - - override fun containsAll(elements: Collection): Boolean { - elements.forEach { element -> - if (!this@ScatterSet.contains(element)) { - return false - } - } - return true - } - - @Suppress("KotlinOperator") - override fun contains(element: E): Boolean { - return this@ScatterSet.contains(element) - } - - override fun isEmpty(): Boolean = this@ScatterSet.isEmpty() - - override fun iterator(): Iterator { - return iterator { this@ScatterSet.forEach { element -> yield(element) } } - } - } + public fun asSet(): Set = SetWrapper(this) } /** @@ -1151,47 +1126,84 @@ public class MutableScatterSet(initialCapacity: Int = DefaultScatterCapacity) * efficient as possible, the semantics of [MutableSet] may require the allocation of temporary * objects for access and iteration. */ - public fun asMutableSet(): MutableSet = MutableSetWrapper() - - private inner class MutableSetWrapper : SetWrapper(), MutableSet { - override fun add(element: E): Boolean = this@MutableScatterSet.add(element) + public fun asMutableSet(): MutableSet = MutableSetWrapper(this) +} - override fun addAll(elements: Collection): Boolean = - this@MutableScatterSet.addAll(elements) +private open class SetWrapper(private val parent: ScatterSet) : Set { + override val size: Int + get() = parent._size - override fun clear() { - this@MutableScatterSet.clear() + override fun containsAll(elements: Collection): Boolean { + elements.forEach { element -> + if (!parent.contains(element)) { + return false + } } + return true + } - override fun iterator(): MutableIterator = - object : MutableIterator { - val parent = this@MutableScatterSet - var current = -1 - val iterator = iterator { - parent.forEachIndex { index -> - current = index - @Suppress("UNCHECKED_CAST") yield(elements[index] as E) - } + @Suppress("KotlinOperator") + override fun contains(element: E): Boolean { + return parent.contains(element) + } + + override fun isEmpty(): Boolean = parent.isEmpty() + + override fun iterator(): Iterator { + return iterator { parent.forEach { element -> yield(element) } } + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other == null || this::class != other::class) return false + + other as SetWrapper<*> + + return parent == other.parent + } + + override fun hashCode(): Int { + return parent.hashCode() + } + + override fun toString(): String = parent.toString() +} + +private class MutableSetWrapper(private val parent: MutableScatterSet) : + SetWrapper(parent), MutableSet { + override fun add(element: E): Boolean = parent.add(element) + + override fun addAll(elements: Collection): Boolean = parent.addAll(elements) + + override fun clear() { + parent.clear() + } + + override fun iterator(): MutableIterator = + object : MutableIterator { + var current = -1 + val iterator = iterator { + parent.forEachIndex { index -> + current = index + @Suppress("UNCHECKED_CAST") yield(parent.elements[index] as E) } + } - override fun hasNext(): Boolean = iterator.hasNext() + override fun hasNext(): Boolean = iterator.hasNext() - override fun next(): E = iterator.next() + override fun next(): E = iterator.next() - override fun remove() { - if (current != -1) { - parent.removeElementAt(current) - current = -1 - } + override fun remove() { + if (current != -1) { + parent.removeElementAt(current) + current = -1 } } + } - override fun remove(element: E): Boolean = this@MutableScatterSet.remove(element) + override fun remove(element: E): Boolean = parent.remove(element) - override fun retainAll(elements: Collection): Boolean = - this@MutableScatterSet.retainAll(elements) + override fun retainAll(elements: Collection): Boolean = parent.retainAll(elements) - override fun removeAll(elements: Collection): Boolean = - this@MutableScatterSet.removeAll(elements) - } + override fun removeAll(elements: Collection): Boolean = parent.removeAll(elements) } diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatFloatMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatFloatMapTest.kt index 211b89c4c2c10..1eeac8fb1e344 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatFloatMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatFloatMapTest.kt @@ -663,6 +663,13 @@ internal class FloatFloatMapTest { map2[1f] = 1f assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableFloatFloatMapOf(1f, 1f, 2f, 2f), + mutableFloatFloatMapOf(1f, 1f, 3f, 2f) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatIntMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatIntMapTest.kt index 868db453c8d48..e7f654009f8f8 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatIntMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatIntMapTest.kt @@ -663,6 +663,10 @@ internal class FloatIntMapTest { map2[1f] = 1 assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableFloatIntMapOf(1f, 1, 2f, 2), mutableFloatIntMapOf(1f, 1, 3f, 2)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatLongMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatLongMapTest.kt index abf7e8666afe2..8ec1291ba738a 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/FloatLongMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/FloatLongMapTest.kt @@ -663,6 +663,13 @@ internal class FloatLongMapTest { map2[1f] = 1L assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableFloatLongMapOf(1f, 1L, 2f, 2L), + mutableFloatLongMapOf(1f, 1L, 3f, 2L) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/IntFloatMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/IntFloatMapTest.kt index 4806d76ea30c1..9d8b893df5c50 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/IntFloatMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/IntFloatMapTest.kt @@ -663,6 +663,10 @@ internal class IntFloatMapTest { map2[1] = 1f assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableIntFloatMapOf(1, 1f, 2, 2f), mutableIntFloatMapOf(1, 1f, 3, 2f)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/IntIntMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/IntIntMapTest.kt index 9c5bc8a122370..a077b8f6efb96 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/IntIntMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/IntIntMapTest.kt @@ -663,6 +663,10 @@ internal class IntIntMapTest { map2[1] = 1 assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableIntIntMapOf(1, 1, 2, 2), mutableIntIntMapOf(1, 1, 3, 2)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/IntLongMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/IntLongMapTest.kt index 0ebe731cc420c..c095601be3830 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/IntLongMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/IntLongMapTest.kt @@ -663,6 +663,10 @@ internal class IntLongMapTest { map2[1] = 1L assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableIntLongMapOf(1, 1L, 2, 2L), mutableIntLongMapOf(1, 1L, 3, 2L)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/LongFloatMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/LongFloatMapTest.kt index 32c25617ce050..4d9c4ac7e271c 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/LongFloatMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/LongFloatMapTest.kt @@ -663,6 +663,13 @@ internal class LongFloatMapTest { map2[1L] = 1f assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableLongFloatMapOf(1L, 1f, 2L, 2f), + mutableLongFloatMapOf(1L, 1f, 3L, 2f) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/LongIntMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/LongIntMapTest.kt index 75c1eeb6bf41b..4ef5c2316c180 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/LongIntMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/LongIntMapTest.kt @@ -663,6 +663,10 @@ internal class LongIntMapTest { map2[1L] = 1 assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableLongIntMapOf(1L, 1, 2L, 2), mutableLongIntMapOf(1L, 1, 3L, 2)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/LongLongMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/LongLongMapTest.kt index c65a12550ae3e..3650d2d8756c0 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/LongLongMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/LongLongMapTest.kt @@ -663,6 +663,10 @@ internal class LongLongMapTest { map2[1L] = 1L assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals(mutableLongLongMapOf(1L, 1L, 2L, 2L), mutableLongLongMapOf(1L, 1L, 3L, 2L)) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectFloatMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectFloatMapTest.kt index b1c506e48df01..d7287a5253ad5 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectFloatMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectFloatMapTest.kt @@ -682,6 +682,13 @@ internal class ObjectFloatTest { map2["Hello"] = 1f assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableObjectFloatMapOf("Hello", 1f, "World", 2f), + mutableObjectFloatMapOf("Hello", 1f, "Foo", 2f) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectIntMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectIntMapTest.kt index 50777bce49777..3713dc646c641 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectIntMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectIntMapTest.kt @@ -682,6 +682,13 @@ internal class ObjectIntTest { map2["Hello"] = 1 assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableObjectIntMapOf("Hello", 1, "World", 2), + mutableObjectIntMapOf("Hello", 1, "Foo", 2) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectLongMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectLongMapTest.kt index 95ed2d8b380c9..a2af351e92746 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectLongMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/ObjectLongMapTest.kt @@ -682,6 +682,13 @@ internal class ObjectLongTest { map2["Hello"] = 1L assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableObjectLongMapOf("Hello", 1L, "World", 2L), + mutableObjectLongMapOf("Hello", 1L, "Foo", 2L) + ) } @Test diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/OrderedScatterSetTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/OrderedScatterSetTest.kt index 9436d11a8839f..34ecf83fe4991 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/OrderedScatterSetTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/OrderedScatterSetTest.kt @@ -929,6 +929,77 @@ class OrderedScatterSetTest { assertFalse("Hola" in set) } + @Test + @JsName("jsAsSetEquals") + fun asSetEquals() { + val set = MutableOrderedScatterSet() + set += "Hello" + set += null + set += "Bonjour" + + assertFalse(set.asSet().equals(null)) + assertFalse(set.asMutableSet().equals(null)) + assertEquals(set.asSet(), set.asSet()) + assertEquals(set.asMutableSet(), set.asMutableSet()) + + val set2 = MutableOrderedScatterSet() + set2 += "Bonjour" + set2 += null + + assertNotEquals(set.asSet(), set2.asSet()) + assertNotEquals(set.asMutableSet(), set2.asMutableSet()) + + set2 += "Hello" + assertEquals(set.asSet(), set2.asSet()) + assertEquals(set.asMutableSet(), set2.asMutableSet()) + } + + @Test + fun asSetString() { + val set = MutableOrderedScatterSet() + assertEquals("[]", set.asSet().toString()) + assertEquals("[]", set.asMutableSet().toString()) + + set += "Hello" + set += "Bonjour" + assertTrue( + "[Hello, Bonjour]" == set.asSet().toString() || + "[Bonjour, Hello]" == set.asSet().toString() + ) + assertTrue( + "[Hello, Bonjour]" == set.asMutableSet().toString() || + "[Bonjour, Hello]" == set.asMutableSet().toString() + ) + + set.clear() + set += null + assertEquals("[null]", set.asSet().toString()) + assertEquals("[null]", set.asMutableSet().toString()) + + set.clear() + + val selfAsElement = MutableScatterSet() + selfAsElement.add(selfAsElement) + assertEquals("[(this)]", selfAsElement.asSet().toString()) + assertEquals("[(this)]", selfAsElement.asMutableSet().toString()) + } + + @Test + fun asSetHashCodeAddValues() { + val set = mutableOrderedScatterSetOf() + assertEquals(217, set.asSet().hashCode()) + assertEquals(217, set.asMutableSet().hashCode()) + set += null + assertEquals(218, set.asSet().hashCode()) + assertEquals(218, set.asMutableSet().hashCode()) + + set += "Hello" + val h1 = set.hashCode() + set += "World" + assertNotEquals(h1, set.asSet().hashCode()) + assertNotEquals(h1, set.asMutableSet().hashCode()) + } + @Test fun trim() { val set = mutableOrderedScatterSetOf("Hello", "World", "Hola", "Mundo", "Bonjour", "Monde") diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterMapTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterMapTest.kt index a85a25595ba09..67fafb268ac93 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterMapTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterMapTest.kt @@ -1399,6 +1399,82 @@ internal class ScatterMapTest { assertFalse(MutableScatterMap().asMutableMap().entries.iterator().hasNext()) } + @Test + @JsName("jsAsMapEquals") + fun asMapEquals() { + val map = MutableScatterMap() + map["Hello"] = "World" + map[null] = "Monde" + map["Bonjour"] = null + + assertFalse(map.asMap().equals(null)) + assertFalse(map.asMutableMap().equals(null)) + assertEquals(map.asMap(), map.asMap()) + assertEquals(map.asMutableMap(), map.asMutableMap()) + + val map2 = MutableScatterMap() + map2["Bonjour"] = null + map2[null] = "Monde" + + assertNotEquals(map.asMap(), map2.asMap()) + assertNotEquals(map.asMutableMap(), map2.asMutableMap()) + + map2["Hello"] = "World" + assertEquals(map.asMap(), map2.asMap()) + assertEquals(map.asMutableMap(), map2.asMutableMap()) + } + + @Test + fun asMapToString() { + val map = MutableScatterMap() + assertEquals("{}", map.asMap().toString()) + assertEquals("{}", map.asMutableMap().toString()) + + map["Hello"] = "World" + map["Bonjour"] = "Monde" + assertTrue( + "{Hello=World, Bonjour=Monde}" == map.asMap().toString() || + "{Bonjour=Monde, Hello=World}" == map.asMap().toString() + ) + assertTrue( + "{Hello=World, Bonjour=Monde}" == map.asMutableMap().toString() || + "{Bonjour=Monde, Hello=World}" == map.asMutableMap().toString() + ) + + map.clear() + map["Hello"] = null + assertEquals("{Hello=null}", map.asMap().toString()) + assertEquals("{Hello=null}", map.asMutableMap().toString()) + + map.clear() + map[null] = "Monde" + assertEquals("{null=Monde}", map.asMap().toString()) + assertEquals("{null=Monde}", map.asMutableMap().toString()) + + val selfAsKeyMap = MutableScatterMap() + selfAsKeyMap[selfAsKeyMap] = "Hello" + assertEquals("{(this)=Hello}", selfAsKeyMap.asMap().toString()) + assertEquals("{(this)=Hello}", selfAsKeyMap.asMutableMap().toString()) + + val selfAsValueMap = MutableScatterMap() + selfAsValueMap["Hello"] = selfAsValueMap + assertEquals("{Hello=(this)}", selfAsValueMap.asMap().toString()) + assertEquals("{Hello=(this)}", selfAsValueMap.asMutableMap().toString()) + + // Test with a small map + val map2 = MutableScatterMap(2) + map2["Hello"] = "World" + map2["Bonjour"] = "Monde" + assertTrue( + "{Hello=World, Bonjour=Monde}" == map2.asMap().toString() || + "{Bonjour=Monde, Hello=World}" == map2.asMap().toString() + ) + assertTrue( + "{Hello=World, Bonjour=Monde}" == map2.asMutableMap().toString() || + "{Bonjour=Monde, Hello=World}" == map2.asMutableMap().toString() + ) + } + @Test fun trim() { val map = MutableScatterMap() diff --git a/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterSetTest.kt b/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterSetTest.kt index 27a235340b3ba..a3552193ed578 100644 --- a/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterSetTest.kt +++ b/collection/collection/src/commonTest/kotlin/androidx/collection/ScatterSetTest.kt @@ -721,6 +721,77 @@ internal class ScatterSetTest { assertFalse("Hola" in set) } + @Test + @JsName("jsAsSetEquals") + fun asSetEquals() { + val set = MutableScatterSet() + set += "Hello" + set += null + set += "Bonjour" + + assertFalse(set.asSet().equals(null)) + assertFalse(set.asMutableSet().equals(null)) + assertEquals(set.asSet(), set.asSet()) + assertEquals(set.asMutableSet(), set.asMutableSet()) + + val set2 = MutableScatterSet() + set2 += "Bonjour" + set2 += null + + assertNotEquals(set.asSet(), set2.asSet()) + assertNotEquals(set.asMutableSet(), set2.asMutableSet()) + + set2 += "Hello" + assertEquals(set.asSet(), set2.asSet()) + assertEquals(set.asMutableSet(), set2.asMutableSet()) + } + + @Test + fun asSetString() { + val set = MutableScatterSet() + assertEquals("[]", set.asSet().toString()) + assertEquals("[]", set.asMutableSet().toString()) + + set += "Hello" + set += "Bonjour" + assertTrue( + "[Hello, Bonjour]" == set.asSet().toString() || + "[Bonjour, Hello]" == set.asSet().toString() + ) + assertTrue( + "[Hello, Bonjour]" == set.asMutableSet().toString() || + "[Bonjour, Hello]" == set.asMutableSet().toString() + ) + + set.clear() + set += null + assertEquals("[null]", set.asSet().toString()) + assertEquals("[null]", set.asMutableSet().toString()) + + set.clear() + + val selfAsElement = MutableScatterSet() + selfAsElement.add(selfAsElement) + assertEquals("[(this)]", selfAsElement.asSet().toString()) + assertEquals("[(this)]", selfAsElement.asMutableSet().toString()) + } + + @Test + fun asSetHashCodeAddValues() { + val set = mutableScatterSetOf() + assertEquals(217, set.asSet().hashCode()) + assertEquals(217, set.asMutableSet().hashCode()) + set += null + assertEquals(218, set.asSet().hashCode()) + assertEquals(218, set.asMutableSet().hashCode()) + + set += "Hello" + val h1 = set.hashCode() + set += "World" + assertNotEquals(h1, set.asSet().hashCode()) + assertNotEquals(h1, set.asMutableSet().hashCode()) + } + @Test fun trim() { val set = mutableScatterSetOf("Hello", "World", "Hola", "Mundo", "Bonjour", "Monde") @@ -756,7 +827,7 @@ internal class ScatterSetTest { @Test fun scatterSetOfEmpty() { - assertSame(emptyScatterSet(), scatterSetOf()) + assertSame(emptyScatterSet(), scatterSetOf()) assertEquals(0, scatterSetOf().size) } diff --git a/collection/collection/src/nativeTest/kotlin/androidx/collection/internal/MemoryModelTest.kt b/collection/collection/src/nativeTest/kotlin/androidx/collection/internal/MemoryModelTest.kt deleted file mode 100644 index e5982dd47bab9..0000000000000 --- a/collection/collection/src/nativeTest/kotlin/androidx/collection/internal/MemoryModelTest.kt +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright 2022 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package androidx.collection.internal - -import kotlin.test.Test -import kotlin.test.assertTrue - -internal class MemoryModelTest { - - @OptIn(ExperimentalStdlibApi::class) - @Test - fun newMemoryModelEnabled() { - assertTrue(isExperimentalMM()) - } -} diff --git a/collection/collection/template/ObjectPValueMap.kt.template b/collection/collection/template/ObjectPValueMap.kt.template index 878080fda7092..3a4fd6dcd12e9 100644 --- a/collection/collection/template/ObjectPValueMap.kt.template +++ b/collection/collection/template/ObjectPValueMap.kt.template @@ -634,7 +634,8 @@ public sealed class ObjectPValueMap { val o = other as ObjectPValueMap forEach { key, value -> - if (value != o[key]) { + val index = o.findKeyIndex(key) + if (index < 0 || value != o.values[index]) { return false } } diff --git a/collection/collection/template/ObjectPValueMapTest.kt.template b/collection/collection/template/ObjectPValueMapTest.kt.template index 56c71bba203f3..497361f55c615 100644 --- a/collection/collection/template/ObjectPValueMapTest.kt.template +++ b/collection/collection/template/ObjectPValueMapTest.kt.template @@ -647,6 +647,19 @@ internal class ObjectPValueTest { map2["Hello"] = 1ValueSuffix assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutableObjectPValueMapOf( + "Hello", 1ValueSuffix, + "World", 2ValueSuffix + ), + mutableObjectPValueMapOf( + "Hello", 1ValueSuffix, + "Foo", 2ValueSuffix + ) + ) } @Test diff --git a/collection/collection/template/PKeyPValueMap.kt.template b/collection/collection/template/PKeyPValueMap.kt.template index 61ac9d8c0ee7b..6d04daaeebcda 100644 --- a/collection/collection/template/PKeyPValueMap.kt.template +++ b/collection/collection/template/PKeyPValueMap.kt.template @@ -614,7 +614,8 @@ public sealed class PKeyPValueMap { } forEach { key, value -> - if (value != other[key]) { + val index = other.findKeyIndex(key) + if (index < 0 || value != other.values[index]) { return false } } diff --git a/collection/collection/template/PKeyPValueMapTest.kt.template b/collection/collection/template/PKeyPValueMapTest.kt.template index 6d6a41612397e..0eade6e372a12 100644 --- a/collection/collection/template/PKeyPValueMapTest.kt.template +++ b/collection/collection/template/PKeyPValueMapTest.kt.template @@ -628,6 +628,19 @@ internal class PKeyPValueMapTest { map2[1KeySuffix] = 1ValueSuffix assertEquals(map, map2) + + // Same number of items but different keys to test that looking up + // a non-existing entry doesn't throw during equals() + assertNotEquals( + mutablePKeyPValueMapOf( + 1KeySuffix, 1ValueSuffix, + 2KeySuffix, 2ValueSuffix + ), + mutablePKeyPValueMapOf( + 1KeySuffix, 1ValueSuffix, + 3KeySuffix, 2ValueSuffix + ) + ) } @Test diff --git a/gradle.properties b/gradle.properties index 033bd13016cfc..a04a5573b3f86 100644 --- a/gradle.properties +++ b/gradle.properties @@ -111,7 +111,7 @@ artifactRedirecting.androidx.compose.material3.common.version=1.0.0-alpha01 # Look for `COMPOSE_MATERIAL3_ADAPTIVE` in libraryversions.toml artifactRedirecting.androidx.compose.material3.adaptive.version=1.1.0-alpha07 # We use artifactRedirecting not only for Compose libs: -artifactRedirecting.androidx.collection.version=1.5.0-alpha06 +artifactRedirecting.androidx.collection.version=1.5.0-beta01 artifactRedirecting.androidx.annotation.version=1.9.1 artifactRedirecting.androidx.graphics.version=1.0.1 artifactRedirecting.androidx.lifecycle.version=2.9.0-alpha03