JVM_IR emulate old back-end behavior in special bridges + inline classes
KT-42491 KT-42539
This commit is contained in:
Dmitry Petrov
Vendored
-137
@@ -1,137 +0,0 @@
|
||||
inline class InlineIterator<T>(private val it: Iterator<T>) : Iterator<T> {
|
||||
override fun hasNext(): Boolean = it.hasNext()
|
||||
override fun next(): T = it.next()
|
||||
}
|
||||
|
||||
inline class InlineMutableIterator<T>(private val it: MutableIterator<T>) : MutableIterator<T> {
|
||||
override fun hasNext(): Boolean = it.hasNext()
|
||||
override fun next(): T = it.next()
|
||||
override fun remove() { it.remove() }
|
||||
}
|
||||
|
||||
inline class InlineIterable<T>(private val it: Iterable<T>) : Iterable<T> {
|
||||
override fun iterator(): Iterator<T> = it.iterator()
|
||||
}
|
||||
|
||||
inline class InlineMutableIterable<T>(private val it: MutableIterable<T>) : MutableIterable<T> {
|
||||
override fun iterator(): MutableIterator<T> = it.iterator()
|
||||
}
|
||||
|
||||
inline class InlineCollection<T>(private val c: Collection<T>) : Collection<T> {
|
||||
override val size: Int get() = c.size
|
||||
override fun contains(element: T): Boolean = c.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = c.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = c.isEmpty()
|
||||
override fun iterator(): Iterator<T> = c.iterator()
|
||||
}
|
||||
|
||||
inline class InlineMutableCollection<T>(private val mc: MutableCollection<T>) : MutableCollection<T> {
|
||||
override val size: Int get() = mc.size
|
||||
override fun contains(element: T): Boolean = mc.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = mc.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = mc.isEmpty()
|
||||
override fun add(element: T): Boolean = mc.add(element)
|
||||
override fun addAll(elements: Collection<T>): Boolean = mc.addAll(elements)
|
||||
override fun clear() { mc.clear() }
|
||||
override fun iterator(): MutableIterator<T> = mc.iterator()
|
||||
override fun remove(element: T): Boolean = mc.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = mc.removeAll(elements)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = mc.retainAll(elements)
|
||||
}
|
||||
|
||||
inline class InlineList<T>(private val list: List<T>) : List<T> {
|
||||
override val size: Int get() = list.size
|
||||
override fun contains(element: T): Boolean = list.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = list.containsAll(elements)
|
||||
override fun get(index: Int): T = list[index]
|
||||
override fun indexOf(element: T): Int = list.indexOf(element)
|
||||
override fun isEmpty(): Boolean = list.isEmpty()
|
||||
override fun iterator(): Iterator<T> = list.iterator()
|
||||
override fun lastIndexOf(element: T): Int = list.lastIndexOf(element)
|
||||
override fun listIterator(): ListIterator<T> = list.listIterator()
|
||||
override fun listIterator(index: Int): ListIterator<T> = list.listIterator(index)
|
||||
override fun subList(fromIndex: Int, toIndex: Int): List<T> = list.subList(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
inline class InlineMutableList<T>(private val mlist: MutableList<T>) : MutableList<T> {
|
||||
override val size: Int get() = mlist.size
|
||||
override fun contains(element: T): Boolean = mlist.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = mlist.containsAll(elements)
|
||||
override fun get(index: Int): T = mlist[index]
|
||||
override fun indexOf(element: T): Int = mlist.indexOf(element)
|
||||
override fun isEmpty(): Boolean = mlist.isEmpty()
|
||||
override fun iterator(): MutableIterator<T> = mlist.iterator()
|
||||
override fun lastIndexOf(element: T): Int = mlist.lastIndexOf(element)
|
||||
override fun add(element: T): Boolean = mlist.add(element)
|
||||
override fun add(index: Int, element: T) { mlist.add(index, element) }
|
||||
override fun addAll(index: Int, elements: Collection<T>): Boolean = mlist.addAll(index, elements)
|
||||
override fun addAll(elements: Collection<T>): Boolean = mlist.addAll(elements)
|
||||
override fun clear() { mlist.clear() }
|
||||
override fun listIterator(): MutableListIterator<T> = mlist.listIterator()
|
||||
override fun listIterator(index: Int): MutableListIterator<T> = mlist.listIterator(index)
|
||||
override fun remove(element: T): Boolean = mlist.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = mlist.removeAll(elements)
|
||||
override fun removeAt(index: Int): T = mlist.removeAt(index)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = mlist.retainAll(elements)
|
||||
override fun set(index: Int, element: T): T = mlist.set(index, element)
|
||||
override fun subList(fromIndex: Int, toIndex: Int): MutableList<T> = mlist.subList(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
inline class InlineSet<T>(private val s: Set<T>) : Set<T> {
|
||||
override val size: Int get() = s.size
|
||||
override fun contains(element: T): Boolean = s.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = s.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = s.isEmpty()
|
||||
override fun iterator(): Iterator<T> = s.iterator()
|
||||
}
|
||||
|
||||
inline class InlineMutableSet<T>(private val ms: MutableSet<T>) : MutableSet<T> {
|
||||
override val size: Int get() = ms.size
|
||||
override fun contains(element: T): Boolean = ms.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = ms.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = ms.isEmpty()
|
||||
override fun add(element: T): Boolean = ms.add(element)
|
||||
override fun addAll(elements: Collection<T>): Boolean = ms.addAll(elements)
|
||||
override fun clear() { ms.clear() }
|
||||
override fun iterator(): MutableIterator<T> = ms.iterator()
|
||||
override fun remove(element: T): Boolean = ms.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = ms.removeAll(elements)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = ms.retainAll(elements)
|
||||
}
|
||||
|
||||
inline class InlineMap<K, V>(private val map: Map<K, V>) : Map<K, V> {
|
||||
override val entries: Set<Map.Entry<K, V>> get() = map.entries
|
||||
override val keys: Set<K> get() = map.keys
|
||||
override val size: Int get() = map.size
|
||||
override val values: Collection<V> get() = map.values
|
||||
override fun containsKey(key: K): Boolean = map.containsKey(key)
|
||||
override fun containsValue(value: V): Boolean = map.containsValue(value)
|
||||
override fun get(key: K): V? = map[key]
|
||||
override fun isEmpty(): Boolean = map.isEmpty()
|
||||
}
|
||||
|
||||
inline class InlineMutableMap<K, V>(private val mmap: MutableMap<K, V>) : MutableMap<K, V> {
|
||||
override val size: Int get() = mmap.size
|
||||
override fun containsKey(key: K): Boolean = mmap.containsKey(key)
|
||||
override fun containsValue(value: V): Boolean = mmap.containsValue(value)
|
||||
override fun get(key: K): V? = mmap[key]
|
||||
override fun isEmpty(): Boolean = mmap.isEmpty()
|
||||
override val entries: MutableSet<MutableMap.MutableEntry<K, V>> get() = mmap.entries
|
||||
override val keys: MutableSet<K> get() = mmap.keys
|
||||
override val values: MutableCollection<V> get() = mmap.values
|
||||
override fun clear() { mmap.clear() }
|
||||
override fun put(key: K, value: V): V? = mmap.put(key, value)
|
||||
override fun putAll(from: Map<out K, V>) { mmap.putAll(from) }
|
||||
override fun remove(key: K): V? = mmap.remove(key)
|
||||
}
|
||||
|
||||
inline class InlineMapEntry<K, V>(private val e: Map.Entry<K, V>) : Map.Entry<K, V> {
|
||||
override val key: K get() = e.key
|
||||
override val value: V get() = e.value
|
||||
}
|
||||
|
||||
inline class InlineMutableMapEntry<K, V>(private val e: MutableMap.MutableEntry<K, V>) : MutableMap.MutableEntry<K, V> {
|
||||
override val key: K get() = e.key
|
||||
override val value: V get() = e.value
|
||||
override fun setValue(newValue: V): V = e.setValue(newValue)
|
||||
}
|
||||
Vendored
-484
@@ -1,484 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class InlineCollection {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field c: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineCollection
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineIterable {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineIterable
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineIterator {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineIterator
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineList {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field list: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineList
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List
|
||||
public static @org.jetbrains.annotations.NotNull method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMap {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field map: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMap
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public bridge final method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection
|
||||
public static @org.jetbrains.annotations.NotNull method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public bridge final method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public bridge final method values(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMapEntry {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMapEntry
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableCollection {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field mc: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableCollection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineMutableCollection
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Collection): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableIterable {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineMutableIterable
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableIterator {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineMutableIterator
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public static method remove-impl(p0: java.util.Iterator): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableList {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field mlist: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.List, p1: int, p2: java.lang.Object): void
|
||||
public static method add-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public method addAll(p0: int, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, p1: int, @org.jetbrains.annotations.NotNull p2: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineMutableList
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.List): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public bridge final method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method removeAt(p0: int): java.lang.Object
|
||||
public static method removeAt-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public static method set-impl(p0: java.util.List, p1: int, p2: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List
|
||||
public static @org.jetbrains.annotations.NotNull method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableMap {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field mmap: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMutableMap
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Map): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public bridge final method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection
|
||||
public static @org.jetbrains.annotations.NotNull method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public bridge final method keySet(): java.util.Set
|
||||
public @org.jetbrains.annotations.Nullable method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method put-impl(p0: java.util.Map, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
|
||||
public method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void
|
||||
public static method putAll-impl(p0: InlineMutableMap, @org.jetbrains.annotations.NotNull p1: java.util.Map): void
|
||||
public @org.jetbrains.annotations.Nullable method remove(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method remove-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public bridge final method values(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableMapEntry {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMutableMapEntry
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public static method setValue-impl(p0: java.util.Map$Entry, p1: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableSet {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field ms: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableSet, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineMutableSet
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Set): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineSet {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final field s: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineSet
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
Vendored
-484
@@ -1,484 +0,0 @@
|
||||
@kotlin.Metadata
|
||||
public final class InlineCollection {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field c: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineCollection
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineIterable {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineIterable
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineIterator {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineIterator
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineList {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field list: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineList
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): int
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List
|
||||
public static @org.jetbrains.annotations.NotNull method subList-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMap {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field map: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMap
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public synthetic bridge method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method get-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Set
|
||||
public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getKeys-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): int
|
||||
public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection
|
||||
public static @org.jetbrains.annotations.NotNull method getValues-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): boolean
|
||||
public synthetic bridge method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public synthetic bridge method values(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMapEntry {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMapEntry
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableCollection {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field mc: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(@org.jetbrains.annotations.NotNull p0: InlineMutableCollection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineMutableCollection
|
||||
public method clear(): void
|
||||
public static method clear-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Collection, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableIterable {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineMutableIterable
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableIterator {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineMutableIterator
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public static method remove-impl(@org.jetbrains.annotations.NotNull p0: java.util.Iterator): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableList {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field mlist: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int, p2: java.lang.Object): void
|
||||
public static method add-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public method addAll(p0: int, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public static method addAll-impl(@org.jetbrains.annotations.NotNull p0: InlineMutableList, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public static method addAll-impl(@org.jetbrains.annotations.NotNull p0: InlineMutableList, p1: int, @org.jetbrains.annotations.NotNull p2: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineMutableList
|
||||
public method clear(): void
|
||||
public static method clear-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): int
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator
|
||||
public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.ListIterator
|
||||
public static @org.jetbrains.annotations.NotNull method listIterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public bridge final method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method removeAt(p0: int): java.lang.Object
|
||||
public static method removeAt-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int): java.lang.Object
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public static method set-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int, p2: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List
|
||||
public static @org.jetbrains.annotations.NotNull method subList-impl(@org.jetbrains.annotations.NotNull p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableMap {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field mmap: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMutableMap
|
||||
public method clear(): void
|
||||
public static method clear-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public synthetic bridge method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method get-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getEntries-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Set
|
||||
public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set
|
||||
public static @org.jetbrains.annotations.NotNull method getKeys-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): int
|
||||
public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection
|
||||
public static @org.jetbrains.annotations.NotNull method getValues-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map): boolean
|
||||
public synthetic bridge method keySet(): java.util.Set
|
||||
public @org.jetbrains.annotations.Nullable method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method put-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
|
||||
public method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void
|
||||
public static method putAll-impl(@org.jetbrains.annotations.NotNull p0: InlineMutableMap, @org.jetbrains.annotations.NotNull p1: java.util.Map): void
|
||||
public @org.jetbrains.annotations.Nullable method remove(p0: java.lang.Object): java.lang.Object
|
||||
public static @org.jetbrains.annotations.Nullable method remove-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public synthetic bridge method values(): java.util.Collection
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableMapEntry {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMutableMapEntry
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public static method setValue-impl(@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry, p1: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineMutableSet {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field ms: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method addAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(@org.jetbrains.annotations.NotNull p0: InlineMutableSet, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineMutableSet
|
||||
public method clear(): void
|
||||
public static method clear-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method removeAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method retainAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
|
||||
@kotlin.Metadata
|
||||
public final class InlineSet {
|
||||
// source: 'inlineClassImplementingCollection.kt'
|
||||
private final @org.jetbrains.annotations.NotNull field s: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineSet
|
||||
public method clear(): void
|
||||
public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set, @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): boolean
|
||||
public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator
|
||||
public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineCollection<T>(private val c: Collection<T>) : Collection<T> {
|
||||
override val size: Int get() = c.size
|
||||
override fun contains(element: T): Boolean = c.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = c.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = c.isEmpty()
|
||||
override fun iterator(): Iterator<T> = c.iterator()
|
||||
}
|
||||
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
public final class InlineCollection {
|
||||
// source: 'collection.kt'
|
||||
private final field c: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineCollection
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
public final class InlineCollection {
|
||||
// source: 'collection.kt'
|
||||
private final field c: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineCollection
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineIterable<T>(private val it: Iterable<T>) : Iterable<T> {
|
||||
override fun iterator(): Iterator<T> = it.iterator()
|
||||
}
|
||||
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
public final class InlineIterable {
|
||||
// source: 'iterable.kt'
|
||||
private final field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineIterable
|
||||
public static method constructor-impl(p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineIterator<T>(private val it: Iterator<T>) : Iterator<T> {
|
||||
override fun hasNext(): Boolean = it.hasNext()
|
||||
override fun next(): T = it.next()
|
||||
}
|
||||
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
public final class InlineIterator {
|
||||
// source: 'iterator.kt'
|
||||
private final field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineIterator
|
||||
public static method constructor-impl(p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineList<T>(private val list: List<T>) : List<T> {
|
||||
override val size: Int get() = list.size
|
||||
override fun contains(element: T): Boolean = list.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = list.containsAll(elements)
|
||||
override fun get(index: Int): T = list[index]
|
||||
override fun indexOf(element: T): Int = list.indexOf(element)
|
||||
override fun isEmpty(): Boolean = list.isEmpty()
|
||||
override fun iterator(): Iterator<T> = list.iterator()
|
||||
override fun lastIndexOf(element: T): Int = list.lastIndexOf(element)
|
||||
override fun listIterator(): ListIterator<T> = list.listIterator()
|
||||
override fun listIterator(index: Int): ListIterator<T> = list.listIterator(index)
|
||||
override fun subList(fromIndex: Int, toIndex: Int): List<T> = list.subList(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
public final class InlineList {
|
||||
// source: 'list.kt'
|
||||
private final field list: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineList
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
public final class InlineList {
|
||||
// source: 'list.kt'
|
||||
private final field list: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineList
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMap<K, V>(private val map: Map<K, V>) : Map<K, V> {
|
||||
override val entries: Set<Map.Entry<K, V>> get() = map.entries
|
||||
override val keys: Set<K> get() = map.keys
|
||||
override val size: Int get() = map.size
|
||||
override val values: Collection<V> get() = map.values
|
||||
override fun containsKey(key: K): Boolean = map.containsKey(key)
|
||||
override fun containsValue(value: V): Boolean = map.containsValue(value)
|
||||
override fun get(key: K): V? = map[key]
|
||||
override fun isEmpty(): Boolean = map.isEmpty()
|
||||
}
|
||||
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
public final class InlineMap {
|
||||
// source: 'map.kt'
|
||||
private final field map: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMap
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public bridge final method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public method get(p0: java.lang.Object): java.lang.Object
|
||||
public static method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public method getEntries(): java.util.Set
|
||||
public static method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public method getKeys(): java.util.Set
|
||||
public static method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public method getValues(): java.util.Collection
|
||||
public static method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public bridge final method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public bridge final method values(): java.util.Collection
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMapEntry<K, V>(private val e: Map.Entry<K, V>) : Map.Entry<K, V> {
|
||||
override val key: K get() = e.key
|
||||
override val value: V get() = e.value
|
||||
}
|
||||
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
public final class InlineMapEntry {
|
||||
// source: 'mapEntry.kt'
|
||||
private final field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMapEntry
|
||||
public static method constructor-impl(p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
public final class InlineMap {
|
||||
// source: 'map.kt'
|
||||
private final field map: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMap
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public synthetic bridge method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public method get(p0: java.lang.Object): java.lang.Object
|
||||
public static method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public method getEntries(): java.util.Set
|
||||
public static method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public method getKeys(): java.util.Set
|
||||
public static method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public method getValues(): java.util.Collection
|
||||
public static method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public synthetic bridge method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public synthetic bridge method values(): java.util.Collection
|
||||
}
|
||||
Vendored
+16
@@ -0,0 +1,16 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableCollection<T>(private val mc: MutableCollection<T>) : MutableCollection<T> {
|
||||
override val size: Int get() = mc.size
|
||||
override fun contains(element: T): Boolean = mc.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = mc.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = mc.isEmpty()
|
||||
override fun add(element: T): Boolean = mc.add(element)
|
||||
override fun addAll(elements: Collection<T>): Boolean = mc.addAll(elements)
|
||||
override fun clear() { mc.clear() }
|
||||
override fun iterator(): MutableIterator<T> = mc.iterator()
|
||||
override fun remove(element: T): Boolean = mc.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = mc.removeAll(elements)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = mc.retainAll(elements)
|
||||
}
|
||||
|
||||
Vendored
+40
@@ -0,0 +1,40 @@
|
||||
public final class InlineMutableCollection {
|
||||
// source: 'mutableCollection.kt'
|
||||
private final field mc: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableCollection, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineMutableCollection
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Collection): void
|
||||
public static method constructor-impl(p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
Vendored
+40
@@ -0,0 +1,40 @@
|
||||
public final class InlineMutableCollection {
|
||||
// source: 'mutableCollection.kt'
|
||||
private final field mc: java.util.Collection
|
||||
private synthetic method <init>(p0: java.util.Collection): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableCollection, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Collection): InlineMutableCollection
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Collection): void
|
||||
public static method constructor-impl(p0: java.util.Collection): java.util.Collection
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Collection): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Collection): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Collection): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Collection): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Collection, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Collection, p1: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Collection): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Collection
|
||||
}
|
||||
Vendored
+6
@@ -0,0 +1,6 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableIterable<T>(private val it: MutableIterable<T>) : MutableIterable<T> {
|
||||
override fun iterator(): MutableIterator<T> = it.iterator()
|
||||
}
|
||||
|
||||
Vendored
+17
@@ -0,0 +1,17 @@
|
||||
public final class InlineMutableIterable {
|
||||
// source: 'mutableIterable.kt'
|
||||
private final field it: java.lang.Iterable
|
||||
private synthetic method <init>(p0: java.lang.Iterable): void
|
||||
public synthetic final static method box-impl(p0: java.lang.Iterable): InlineMutableIterable
|
||||
public static method constructor-impl(p0: java.lang.Iterable): java.lang.Iterable
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.lang.Iterable, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.lang.Iterable, p1: java.lang.Iterable): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.lang.Iterable): int
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.lang.Iterable): java.util.Iterator
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.lang.Iterable): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.lang.Iterable
|
||||
}
|
||||
Vendored
+8
@@ -0,0 +1,8 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableIterator<T>(private val it: MutableIterator<T>) : MutableIterator<T> {
|
||||
override fun hasNext(): Boolean = it.hasNext()
|
||||
override fun next(): T = it.next()
|
||||
override fun remove() { it.remove() }
|
||||
}
|
||||
|
||||
Vendored
+21
@@ -0,0 +1,21 @@
|
||||
public final class InlineMutableIterator {
|
||||
// source: 'mutableIterator.kt'
|
||||
private final field it: java.util.Iterator
|
||||
private synthetic method <init>(p0: java.util.Iterator): void
|
||||
public synthetic final static method box-impl(p0: java.util.Iterator): InlineMutableIterator
|
||||
public static method constructor-impl(p0: java.util.Iterator): java.util.Iterator
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Iterator, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Iterator, p1: java.util.Iterator): boolean
|
||||
public method hasNext(): boolean
|
||||
public static method hasNext-impl(p0: java.util.Iterator): boolean
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Iterator): int
|
||||
public method next(): java.lang.Object
|
||||
public static method next-impl(p0: java.util.Iterator): java.lang.Object
|
||||
public method remove(): void
|
||||
public static method remove-impl(p0: java.util.Iterator): void
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Iterator): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Iterator
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableList<T>(private val mlist: MutableList<T>) : MutableList<T> {
|
||||
override val size: Int get() = mlist.size
|
||||
override fun contains(element: T): Boolean = mlist.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = mlist.containsAll(elements)
|
||||
override fun get(index: Int): T = mlist[index]
|
||||
override fun indexOf(element: T): Int = mlist.indexOf(element)
|
||||
override fun isEmpty(): Boolean = mlist.isEmpty()
|
||||
override fun iterator(): MutableIterator<T> = mlist.iterator()
|
||||
override fun lastIndexOf(element: T): Int = mlist.lastIndexOf(element)
|
||||
override fun add(element: T): Boolean = mlist.add(element)
|
||||
override fun add(index: Int, element: T) { mlist.add(index, element) }
|
||||
override fun addAll(index: Int, elements: Collection<T>): Boolean = mlist.addAll(index, elements)
|
||||
override fun addAll(elements: Collection<T>): Boolean = mlist.addAll(elements)
|
||||
override fun clear() { mlist.clear() }
|
||||
override fun listIterator(): MutableListIterator<T> = mlist.listIterator()
|
||||
override fun listIterator(index: Int): MutableListIterator<T> = mlist.listIterator(index)
|
||||
override fun remove(element: T): Boolean = mlist.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = mlist.removeAll(elements)
|
||||
override fun removeAt(index: Int): T = mlist.removeAt(index)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = mlist.retainAll(elements)
|
||||
override fun set(index: Int, element: T): T = mlist.set(index, element)
|
||||
override fun subList(fromIndex: Int, toIndex: Int): MutableList<T> = mlist.subList(fromIndex, toIndex)
|
||||
}
|
||||
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
public final class InlineMutableList {
|
||||
// source: 'mutableList.kt'
|
||||
private final field mlist: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.List, p1: int, p2: java.lang.Object): void
|
||||
public static method add-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, p1: int, p2: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineMutableList
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.List): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public bridge final method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method removeAt(p0: int): java.lang.Object
|
||||
public static method removeAt-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public static method set-impl(p0: java.util.List, p1: int, p2: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
Vendored
+61
@@ -0,0 +1,61 @@
|
||||
public final class InlineMutableList {
|
||||
// source: 'mutableList.kt'
|
||||
private final field mlist: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.List, p1: int, p2: java.lang.Object): void
|
||||
public static method add-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, p1: int, p2: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableList, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineMutableList
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.List): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public method get(p0: int): java.lang.Object
|
||||
public static method get-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-impl(p0: java.util.List, p1: java.lang.Object): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public bridge final method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method removeAt(p0: int): java.lang.Object
|
||||
public static method removeAt-impl(p0: java.util.List, p1: int): java.lang.Object
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public static method set-impl(p0: java.util.List, p1: int, p2: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableMap<K, V>(private val mmap: MutableMap<K, V>) : MutableMap<K, V> {
|
||||
override val size: Int get() = mmap.size
|
||||
override fun containsKey(key: K): Boolean = mmap.containsKey(key)
|
||||
override fun containsValue(value: V): Boolean = mmap.containsValue(value)
|
||||
override fun get(key: K): V? = mmap[key]
|
||||
override fun isEmpty(): Boolean = mmap.isEmpty()
|
||||
override val entries: MutableSet<MutableMap.MutableEntry<K, V>> get() = mmap.entries
|
||||
override val keys: MutableSet<K> get() = mmap.keys
|
||||
override val values: MutableCollection<V> get() = mmap.values
|
||||
override fun clear() { mmap.clear() }
|
||||
override fun put(key: K, value: V): V? = mmap.put(key, value)
|
||||
override fun putAll(from: Map<out K, V>) { mmap.putAll(from) }
|
||||
override fun remove(key: K): V? = mmap.remove(key)
|
||||
}
|
||||
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
public final class InlineMutableMap {
|
||||
// source: 'mutableMap.kt'
|
||||
private final field mmap: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMutableMap
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Map): void
|
||||
public static method constructor-impl(p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public bridge final method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public method get(p0: java.lang.Object): java.lang.Object
|
||||
public static method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public method getEntries(): java.util.Set
|
||||
public static method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public method getKeys(): java.util.Set
|
||||
public static method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public method getValues(): java.util.Collection
|
||||
public static method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public bridge final method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public static method put-impl(p0: java.util.Map, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public static method putAll-impl(p0: InlineMutableMap, p1: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public static method remove-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public bridge final method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public bridge final method values(): java.util.Collection
|
||||
}
|
||||
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableMapEntry<K, V>(private val e: MutableMap.MutableEntry<K, V>) : MutableMap.MutableEntry<K, V> {
|
||||
override val key: K get() = e.key
|
||||
override val value: V get() = e.value
|
||||
override fun setValue(newValue: V): V = e.setValue(newValue)
|
||||
}
|
||||
Vendored
+21
@@ -0,0 +1,21 @@
|
||||
public final class InlineMutableMapEntry {
|
||||
// source: 'mutableMapEntry.kt'
|
||||
private final field e: java.util.Map$Entry
|
||||
private synthetic method <init>(p0: java.util.Map$Entry): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMutableMapEntry
|
||||
public static method constructor-impl(p0: java.util.Map$Entry): java.util.Map$Entry
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean
|
||||
public method getKey(): java.lang.Object
|
||||
public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method getValue(): java.lang.Object
|
||||
public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map$Entry): int
|
||||
public method setValue(p0: java.lang.Object): java.lang.Object
|
||||
public static method setValue-impl(p0: java.util.Map$Entry, p1: java.lang.Object): java.lang.Object
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map$Entry): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map$Entry
|
||||
}
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
public final class InlineMutableMap {
|
||||
// source: 'mutableMap.kt'
|
||||
private final field mmap: java.util.Map
|
||||
private synthetic method <init>(p0: java.util.Map): void
|
||||
public synthetic final static method box-impl(p0: java.util.Map): InlineMutableMap
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Map): void
|
||||
public static method constructor-impl(p0: java.util.Map): java.util.Map
|
||||
public method containsKey(p0: java.lang.Object): boolean
|
||||
public static method containsKey-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public method containsValue(p0: java.lang.Object): boolean
|
||||
public static method containsValue-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public synthetic bridge method entrySet(): java.util.Set
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Map, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Map, p1: java.util.Map): boolean
|
||||
public method get(p0: java.lang.Object): java.lang.Object
|
||||
public static method get-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public method getEntries(): java.util.Set
|
||||
public static method getEntries-impl(p0: java.util.Map): java.util.Set
|
||||
public method getKeys(): java.util.Set
|
||||
public static method getKeys-impl(p0: java.util.Map): java.util.Set
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Map): int
|
||||
public method getValues(): java.util.Collection
|
||||
public static method getValues-impl(p0: java.util.Map): java.util.Collection
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Map): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Map): boolean
|
||||
public synthetic bridge method keySet(): java.util.Set
|
||||
public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
|
||||
public static method put-impl(p0: java.util.Map, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
|
||||
public method putAll(p0: java.util.Map): void
|
||||
public static method putAll-impl(p0: InlineMutableMap, p1: java.util.Map): void
|
||||
public method remove(p0: java.lang.Object): java.lang.Object
|
||||
public static method remove-impl(p0: java.util.Map, p1: java.lang.Object): java.lang.Object
|
||||
public synthetic bridge method size(): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Map): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Map
|
||||
public synthetic bridge method values(): java.util.Collection
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineMutableSet<T>(private val ms: MutableSet<T>) : MutableSet<T> {
|
||||
override val size: Int get() = ms.size
|
||||
override fun contains(element: T): Boolean = ms.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = ms.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = ms.isEmpty()
|
||||
override fun add(element: T): Boolean = ms.add(element)
|
||||
override fun addAll(elements: Collection<T>): Boolean = ms.addAll(elements)
|
||||
override fun clear() { ms.clear() }
|
||||
override fun iterator(): MutableIterator<T> = ms.iterator()
|
||||
override fun remove(element: T): Boolean = ms.remove(element)
|
||||
override fun removeAll(elements: Collection<T>): Boolean = ms.removeAll(elements)
|
||||
override fun retainAll(elements: Collection<T>): Boolean = ms.retainAll(elements)
|
||||
}
|
||||
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
public final class InlineMutableSet {
|
||||
// source: 'mutableSet.kt'
|
||||
private final field ms: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableSet, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineMutableSet
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Set): void
|
||||
public static method constructor-impl(p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
public final class InlineMutableSet {
|
||||
// source: 'mutableSet.kt'
|
||||
private final field ms: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public static method add-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: InlineMutableSet, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineMutableSet
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.Set): void
|
||||
public static method constructor-impl(p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
inline class InlineSet<T>(private val s: Set<T>) : Set<T> {
|
||||
override val size: Int get() = s.size
|
||||
override fun contains(element: T): Boolean = s.contains(element)
|
||||
override fun containsAll(elements: Collection<T>): Boolean = s.containsAll(elements)
|
||||
override fun isEmpty(): Boolean = s.isEmpty()
|
||||
override fun iterator(): Iterator<T> = s.iterator()
|
||||
}
|
||||
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
public final class InlineSet {
|
||||
// source: 'set.kt'
|
||||
private final field s: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineSet
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
public final class InlineSet {
|
||||
// source: 'set.kt'
|
||||
private final field s: java.util.Set
|
||||
private synthetic method <init>(p0: java.util.Set): void
|
||||
public method add(p0: java.lang.Object): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.Set): InlineSet
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.Set): java.util.Set
|
||||
public method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.Set, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.Set, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.Set, p1: java.util.Set): boolean
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.Set): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.Set): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.Set): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.Set): java.util.Iterator
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.Set): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.Set
|
||||
}
|
||||
Vendored
-2
@@ -1,6 +1,4 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
// IGNORE_BACKEND: JVM_IR
|
||||
// ^ TODO: special bridges <-> inline classes interaction
|
||||
|
||||
inline class IT(val x: Int)
|
||||
|
||||
|
||||
Vendored
+75
@@ -0,0 +1,75 @@
|
||||
public final class IT {
|
||||
// source: 'list.kt'
|
||||
private final field x: int
|
||||
private synthetic method <init>(p0: int): void
|
||||
public synthetic final static method box-impl(p0: int): IT
|
||||
public static method constructor-impl(p0: int): int
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: int, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: int, p1: int): boolean
|
||||
public final method getX(): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: int): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: int): java.lang.String
|
||||
public synthetic final method unbox-impl(): int
|
||||
}
|
||||
|
||||
public final class InlineList {
|
||||
// source: 'list.kt'
|
||||
private final field list: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public synthetic bridge method add(p0: int, p1: java.lang.Object): void
|
||||
public synthetic bridge method add(p0: java.lang.Object): boolean
|
||||
public method add-_bimVNw(p0: int, p1: int): void
|
||||
public method add-jHY5zpA(p0: int): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineList
|
||||
public method clear(): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public synthetic bridge method contains(p0: java.lang.Object): boolean
|
||||
public method contains-jHY5zpA(p0: int): boolean
|
||||
public static method contains-jHY5zpA(p0: java.util.List, p1: int): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public synthetic bridge method get(p0: int): java.lang.Object
|
||||
public method get-XAcLw3A(p0: int): int
|
||||
public static method get-XAcLw3A(p0: java.util.List, p1: int): int
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public synthetic bridge method indexOf(p0: java.lang.Object): int
|
||||
public method indexOf-jHY5zpA(p0: int): int
|
||||
public static method indexOf-jHY5zpA(p0: java.util.List, p1: int): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public synthetic bridge method lastIndexOf(p0: java.lang.Object): int
|
||||
public method lastIndexOf-jHY5zpA(p0: int): int
|
||||
public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: int): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public method remove(p0: int): int
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public method remove(p0: java.lang.Object): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public method set-_bimVNw(p0: int, p1: int): int
|
||||
public synthetic bridge method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableList.kt
Vendored
+1
-3
@@ -1,8 +1,6 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
// IGNORE_BACKEND: JVM_IR
|
||||
// ^ TODO: special bridges <-> inline classes interaction
|
||||
|
||||
inline class IT(val x: Int)
|
||||
inline class IT(val x: Long)
|
||||
|
||||
inline class InlineMutableList(private val mlist: MutableList<IT>) : MutableList<IT> {
|
||||
override val size: Int get() = mlist.size
|
||||
|
||||
+29
-29
@@ -1,18 +1,18 @@
|
||||
public final class IT {
|
||||
// source: 'mutableList.kt'
|
||||
private final field x: int
|
||||
private synthetic method <init>(p0: int): void
|
||||
public synthetic final static method box-impl(p0: int): IT
|
||||
public static method constructor-impl(p0: int): int
|
||||
private final field x: long
|
||||
private synthetic method <init>(p0: long): void
|
||||
public synthetic final static method box-impl(p0: long): IT
|
||||
public static method constructor-impl(p0: long): long
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: int, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: int, p1: int): boolean
|
||||
public final method getX(): int
|
||||
public static method equals-impl(p0: long, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: long, p1: long): boolean
|
||||
public final method getX(): long
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: int): int
|
||||
public static method hashCode-impl(p0: long): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: int): java.lang.String
|
||||
public synthetic final method unbox-impl(): int
|
||||
public static method toString-impl(p0: long): java.lang.String
|
||||
public synthetic final method unbox-impl(): long
|
||||
}
|
||||
|
||||
public final class InlineMutableList {
|
||||
@@ -21,10 +21,10 @@ public final class InlineMutableList {
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public synthetic bridge method add(p0: int, p1: java.lang.Object): void
|
||||
public synthetic bridge method add(p0: java.lang.Object): boolean
|
||||
public method add-_bimVNw(p0: int, p1: int): void
|
||||
public static method add-_bimVNw(p0: java.util.List, p1: int, p2: int): void
|
||||
public method add-jHY5zpA(p0: int): boolean
|
||||
public static method add-jHY5zpA(p0: java.util.List, p1: int): boolean
|
||||
public method add-_bimVNw(p0: int, p1: long): void
|
||||
public static method add-_bimVNw(p0: java.util.List, p1: int, p2: long): void
|
||||
public static method add-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method add-jHY5zpA(p0: long): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: java.util.List, p1: int, p2: java.util.Collection): boolean
|
||||
@@ -34,48 +34,48 @@ public final class InlineMutableList {
|
||||
public static method clear-impl(p0: java.util.List): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public bridge final method contains(p0: java.lang.Object): boolean
|
||||
public method contains-jHY5zpA(p0: int): boolean
|
||||
public static method contains-jHY5zpA(p0: java.util.List, p1: int): boolean
|
||||
public static method contains-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method contains-jHY5zpA(p0: long): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public synthetic bridge method get(p0: int): java.lang.Object
|
||||
public method get-XAcLw3A(p0: int): int
|
||||
public static method get-XAcLw3A(p0: java.util.List, p1: int): int
|
||||
public method get-XAcLw3A(p0: int): long
|
||||
public static method get-XAcLw3A(p0: java.util.List, p1: int): long
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public bridge final method indexOf(p0: java.lang.Object): int
|
||||
public method indexOf-jHY5zpA(p0: int): int
|
||||
public static method indexOf-jHY5zpA(p0: java.util.List, p1: int): int
|
||||
public static method indexOf-jHY5zpA(p0: java.util.List, p1: long): int
|
||||
public method indexOf-jHY5zpA(p0: long): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public bridge final method lastIndexOf(p0: java.lang.Object): int
|
||||
public method lastIndexOf-jHY5zpA(p0: int): int
|
||||
public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: int): int
|
||||
public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: long): int
|
||||
public method lastIndexOf-jHY5zpA(p0: long): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public bridge final method remove(p0: int): int
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public bridge final method remove(p0: int): long
|
||||
public bridge final method remove(p0: java.lang.Object): boolean
|
||||
public method remove-jHY5zpA(p0: IT): boolean
|
||||
public static method remove-jHY5zpA(p0: java.util.List, p1: IT): boolean
|
||||
public static method remove-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method remove-jHY5zpA(p0: long): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method removeAt-XAcLw3A(p0: int): int
|
||||
public static method removeAt-XAcLw3A(p0: java.util.List, p1: int): int
|
||||
public method removeAt-XAcLw3A(p0: int): long
|
||||
public static method removeAt-XAcLw3A(p0: java.util.List, p1: int): long
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public synthetic bridge method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public method set-_bimVNw(p0: int, p1: int): int
|
||||
public static method set-_bimVNw(p0: java.util.List, p1: int, p2: int): int
|
||||
public method set-_bimVNw(p0: int, p1: long): long
|
||||
public static method set-_bimVNw(p0: java.util.List, p1: int, p2: long): long
|
||||
public bridge final method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
public final class IT {
|
||||
// source: 'mutableList.kt'
|
||||
private final field x: long
|
||||
private synthetic method <init>(p0: long): void
|
||||
public synthetic final static method box-impl(p0: long): IT
|
||||
public static method constructor-impl(p0: long): long
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: long, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: long, p1: long): boolean
|
||||
public final method getX(): long
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: long): int
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: long): java.lang.String
|
||||
public synthetic final method unbox-impl(): long
|
||||
}
|
||||
|
||||
public final class InlineMutableList {
|
||||
// source: 'mutableList.kt'
|
||||
private final field mlist: java.util.List
|
||||
private synthetic method <init>(p0: java.util.List): void
|
||||
public synthetic bridge method add(p0: int, p1: java.lang.Object): void
|
||||
public synthetic bridge method add(p0: java.lang.Object): boolean
|
||||
public method add-_bimVNw(p0: int, p1: long): void
|
||||
public static method add-_bimVNw(p0: java.util.List, p1: int, p2: long): void
|
||||
public static method add-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method add-jHY5zpA(p0: long): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: java.util.List, p1: int, p2: java.util.Collection): boolean
|
||||
public static method addAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public synthetic final static method box-impl(p0: java.util.List): InlineMutableList
|
||||
public method clear(): void
|
||||
public static method clear-impl(p0: java.util.List): void
|
||||
public static method constructor-impl(p0: java.util.List): java.util.List
|
||||
public synthetic bridge method contains(p0: java.lang.Object): boolean
|
||||
public static method contains-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method contains-jHY5zpA(p0: long): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public static method containsAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method equals(p0: java.lang.Object): boolean
|
||||
public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean
|
||||
public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean
|
||||
public synthetic bridge method get(p0: int): java.lang.Object
|
||||
public method get-XAcLw3A(p0: int): long
|
||||
public static method get-XAcLw3A(p0: java.util.List, p1: int): long
|
||||
public method getSize(): int
|
||||
public static method getSize-impl(p0: java.util.List): int
|
||||
public method hashCode(): int
|
||||
public static method hashCode-impl(p0: java.util.List): int
|
||||
public synthetic bridge method indexOf(p0: java.lang.Object): int
|
||||
public static method indexOf-jHY5zpA(p0: java.util.List, p1: long): int
|
||||
public method indexOf-jHY5zpA(p0: long): int
|
||||
public method isEmpty(): boolean
|
||||
public static method isEmpty-impl(p0: java.util.List): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public static method iterator-impl(p0: java.util.List): java.util.Iterator
|
||||
public synthetic bridge method lastIndexOf(p0: java.lang.Object): int
|
||||
public static method lastIndexOf-jHY5zpA(p0: java.util.List, p1: long): int
|
||||
public method lastIndexOf-jHY5zpA(p0: long): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List): java.util.ListIterator
|
||||
public static method listIterator-impl(p0: java.util.List, p1: int): java.util.ListIterator
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public bridge final method remove(p0: int): long
|
||||
public synthetic bridge method remove(p0: java.lang.Object): boolean
|
||||
public static method remove-jHY5zpA(p0: java.util.List, p1: long): boolean
|
||||
public method remove-jHY5zpA(p0: long): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public static method removeAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public method removeAt-XAcLw3A(p0: int): long
|
||||
public static method removeAt-XAcLw3A(p0: java.util.List, p1: int): long
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public static method retainAll-impl(p0: java.util.List, p1: java.util.Collection): boolean
|
||||
public synthetic bridge method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public method set-_bimVNw(p0: int, p1: long): long
|
||||
public static method set-_bimVNw(p0: java.util.List, p1: int, p2: long): long
|
||||
public synthetic bridge method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public static method subList-impl(p0: java.util.List, p1: int, p2: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
public method toString(): java.lang.String
|
||||
public static method toString-impl(p0: java.util.List): java.lang.String
|
||||
public synthetic final method unbox-impl(): java.util.List
|
||||
}
|
||||
Vendored
+3
@@ -0,0 +1,3 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
abstract class MutableCollectionOfLong : MutableList<Long>
|
||||
Vendored
+19
@@ -0,0 +1,19 @@
|
||||
public abstract class MutableCollectionOfLong {
|
||||
// source: 'abstractMutableCollectionOfPrimitive.kt'
|
||||
public method <init>(): void
|
||||
public bridge final method contains(p0: java.lang.Object): boolean
|
||||
public abstract method contains(p0: long): boolean
|
||||
public abstract method getSize(): int
|
||||
public bridge final method indexOf(p0: java.lang.Object): int
|
||||
public abstract method indexOf(p0: long): int
|
||||
public bridge final method lastIndexOf(p0: java.lang.Object): int
|
||||
public abstract method lastIndexOf(p0: long): int
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public bridge final method remove(p0: int): long
|
||||
public bridge final method remove(p0: java.lang.Object): boolean
|
||||
public abstract method remove(p0: long): boolean
|
||||
public abstract method removeAt(p0: int): java.lang.Long
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
abstract class MutableListOfLong : MutableList<Long>
|
||||
Vendored
+19
@@ -0,0 +1,19 @@
|
||||
public abstract class MutableListOfLong {
|
||||
// source: 'abstractMutableListOfPrimitive.kt'
|
||||
public method <init>(): void
|
||||
public bridge final method contains(p0: java.lang.Object): boolean
|
||||
public abstract method contains(p0: long): boolean
|
||||
public abstract method getSize(): int
|
||||
public bridge final method indexOf(p0: java.lang.Object): int
|
||||
public abstract method indexOf(p0: long): int
|
||||
public bridge final method lastIndexOf(p0: java.lang.Object): int
|
||||
public abstract method lastIndexOf(p0: long): int
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public bridge final method remove(p0: int): long
|
||||
public bridge final method remove(p0: java.lang.Object): boolean
|
||||
public abstract method remove(p0: long): boolean
|
||||
public abstract method removeAt(p0: int): java.lang.Long
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
}
|
||||
+2
-2
@@ -33,11 +33,11 @@ public abstract class AMLI {
|
||||
public bridge final method indexOf(p0: java.lang.Object): int
|
||||
public abstract method lastIndexOf(p0: int): int
|
||||
public bridge final method lastIndexOf(p0: java.lang.Object): int
|
||||
public bridge final method remove(p0: int): java.lang.Integer
|
||||
public bridge final method remove(p0: int): int
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public abstract method remove(p0: java.lang.Integer): boolean
|
||||
public bridge final method remove(p0: java.lang.Object): boolean
|
||||
public abstract method removeAt(p0: int): int
|
||||
public abstract method removeAt(p0: int): java.lang.Integer
|
||||
public bridge final method size(): int
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
// IGNORE_ANNOTATIONS
|
||||
|
||||
class MutableListOfLong(private val ml: MutableList<Long>) : MutableList<Long> {
|
||||
override val size: Int get() = ml.size
|
||||
override fun contains(element: Long): Boolean = ml.contains(element)
|
||||
override fun containsAll(elements: Collection<Long>): Boolean = ml.containsAll(elements)
|
||||
override fun get(index: Int): Long = ml.get(index)
|
||||
override fun indexOf(element: Long): Int = ml.indexOf(element)
|
||||
override fun isEmpty(): Boolean = ml.isEmpty()
|
||||
override fun iterator(): MutableIterator<Long> = ml.iterator()
|
||||
override fun lastIndexOf(element: Long): Int = ml.lastIndexOf(element)
|
||||
override fun add(element: Long): Boolean = ml.add(element)
|
||||
override fun add(index: Int, element: Long) = ml.add(index, element)
|
||||
override fun addAll(index: Int, elements: Collection<Long>): Boolean = ml.addAll(index, elements)
|
||||
override fun addAll(elements: Collection<Long>): Boolean = ml.addAll(elements)
|
||||
override fun clear() = ml.clear()
|
||||
override fun listIterator(): MutableListIterator<Long> = ml.listIterator()
|
||||
override fun listIterator(index: Int): MutableListIterator<Long> = ml.listIterator(index)
|
||||
override fun remove(element: Long): Boolean = ml.remove(element)
|
||||
override fun removeAll(elements: Collection<Long>): Boolean = ml.removeAll(elements)
|
||||
override fun removeAt(index: Int): Long = ml.removeAt(index)
|
||||
override fun retainAll(elements: Collection<Long>): Boolean = ml.retainAll(elements)
|
||||
override fun set(index: Int, element: Long): Long = ml.set(index, element)
|
||||
override fun subList(fromIndex: Int, toIndex: Int): MutableList<Long> = ml.subList(fromIndex, toIndex)
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
public final class MutableListOfLong {
|
||||
// source: 'mutableListOfPrimitive.kt'
|
||||
private final field ml: java.util.List
|
||||
public method <init>(p0: java.util.List): void
|
||||
public synthetic bridge method add(p0: int, p1: java.lang.Object): void
|
||||
public method add(p0: int, p1: long): void
|
||||
public synthetic bridge method add(p0: java.lang.Object): boolean
|
||||
public method add(p0: long): boolean
|
||||
public method addAll(p0: int, p1: java.util.Collection): boolean
|
||||
public method addAll(p0: java.util.Collection): boolean
|
||||
public method clear(): void
|
||||
public bridge final method contains(p0: java.lang.Object): boolean
|
||||
public method contains(p0: long): boolean
|
||||
public method containsAll(p0: java.util.Collection): boolean
|
||||
public method get(p0: int): java.lang.Long
|
||||
public synthetic bridge method get(p0: int): java.lang.Object
|
||||
public method getSize(): int
|
||||
public bridge final method indexOf(p0: java.lang.Object): int
|
||||
public method indexOf(p0: long): int
|
||||
public method isEmpty(): boolean
|
||||
public method iterator(): java.util.Iterator
|
||||
public bridge final method lastIndexOf(p0: java.lang.Object): int
|
||||
public method lastIndexOf(p0: long): int
|
||||
public method listIterator(): java.util.ListIterator
|
||||
public method listIterator(p0: int): java.util.ListIterator
|
||||
public synthetic bridge method remove(p0: int): java.lang.Object
|
||||
public bridge final method remove(p0: int): long
|
||||
public bridge final method remove(p0: java.lang.Object): boolean
|
||||
public method remove(p0: long): boolean
|
||||
public method removeAll(p0: java.util.Collection): boolean
|
||||
public method removeAt(p0: int): java.lang.Long
|
||||
public method retainAll(p0: java.util.Collection): boolean
|
||||
public synthetic bridge method set(p0: int, p1: java.lang.Object): java.lang.Object
|
||||
public method set(p0: int, p1: long): java.lang.Long
|
||||
public bridge final method size(): int
|
||||
public method subList(p0: int, p1: int): java.util.List
|
||||
public method toArray(): java.lang.Object[]
|
||||
public method toArray(p0: java.lang.Object[]): java.lang.Object[]
|
||||
}
|
||||
Reference in New Issue
Block a user