rd-core/com.jetbrains.rd.util

Package-level declarations

Types

AtomicInteger

typealias AtomicInteger = java.util.concurrent.atomic.AtomicInteger

AtomicReference

class AtomicReference<T>(initial: T)

BitSlice

open class BitSlice(val lowBit: Int, val bitCount: Int)

Boxed

class Boxed<T>(var value: T)

Callable

typealias Callable<T> = java.util.concurrent.Callable<T>

CancellationException

typealias CancellationException = java.util.concurrent.CancellationException

Closeable

typealias Closeable = java.io.Closeable

CommonsLoggingLoggerFactory

object CommonsLoggingLoggerFactory : ILoggerFactory

ConcurrentHashMap

typealias ConcurrentHashMap<K, V> = java.util.concurrent.ConcurrentHashMap<K, V>

ConsoleLoggerFactory

object ConsoleLoggerFactory : ILoggerFactory

CopyOnWriteArrayList

typealias CopyOnWriteArrayList<T> = java.util.concurrent.CopyOnWriteArrayList<T>

Date

typealias Date = java.util.Date

EnumSet

typealias EnumSet<T> = java.util.EnumSet<T>

ExecutionException

typealias ExecutionException = java.util.concurrent.ExecutionException

ILoggerFactory

interface ILoggerFactory

Logger

interface Logger

LogLevel

enum LogLevel : Enum<LogLevel>

Maybe

sealed class Maybe<out T>

Classical Maybe monad

PublicApi

annotation class PublicApi

Queue

typealias Queue<E> = LinkedBlockingQueue<E>

RdDefaultErrorLoggerHolder

object RdDefaultErrorLoggerHolder

Result

sealed class Result<out T>

Classical Result monad

Runnable

typealias Runnable = java.lang.Runnable

Statics

class Statics<T : Any>

Globals statics for classes managed in a stack-like way

SwitchLogger

class SwitchLogger(category: String) : Logger

Sync

object Sync

ThreadLocal

typealias ThreadLocal<T> = java.lang.ThreadLocal<T>

TimeoutException

typealias TimeoutException = java.util.concurrent.TimeoutException

TlsBoxed

class TlsBoxed<T>(initialValue: T)

URI

typealias URI = java.net.URI

UsedImplicitly

annotation class UsedImplicitly

UUID

typealias UUID = java.util.UUID

Properties

eol

val eol: String

Functions

addUnique

fun <T> MutableCollection<T>.addUnique(lifetime: Lifetime, value: T)

fun <K, V> MutableMap<K, V>.addUnique(lifetime: Lifetime, key: K, value: V): V

asNullable

fun <T : Any> Maybe<T>.asNullable(): T?

asProperty

fun <T> ISource<T>.asProperty(defaultValue: T): IPropertyView<T>

assert

fun assert(value: Boolean)

inline fun assert(value: Boolean, lazyMessage: () -> Any)

blockingPutUnique

fun <K, V> MutableMap<K, V>.blockingPutUnique(lf: Lifetime, lock: Any, key: K, value: V)

catch

inline fun catch(action: () -> Unit)

inline fun catch(comment: String?, action: () -> Unit)

catch

inline fun Logger.catch(action: () -> Unit)

inline fun Logger.catch(comment: String?, action: () -> Unit)

catchAndDrop

inline fun catchAndDrop(action: () -> Unit)

concurrentMapOf

fun <K, V> concurrentMapOf(): MutableMap<K, V>

currentThreadName

fun currentThreadName(): String

debounceNotNull

fun <T : Any> IPropertyView<T?>.debounceNotNull(timeout: Duration, scheduler: IScheduler): ISource<T?>

debug

inline fun Logger.debug(msg: () -> Any?)

defaultLogFormat

fun defaultLogFormat(category: String, level: LogLevel, message: Any?, throwable: Throwable?): String

enumSetOf

inline fun <T : Enum<T>> enumSetOf(values: Set<T> = emptySet()): EnumSet<T>

error

inline fun Logger.error(msg: () -> Any?)

fun Logger.error(throwable: Throwable)

fun Logger.error(msg: String?, throwable: Throwable)

first

fun <TKey, TValue> Map<TKey, TValue>.first(): Map.Entry<TKey, TValue>

firstOrNull

fun <TKey, TValue> Map<TKey, TValue>.firstOrNull(): Map.Entry<TKey, TValue>?

forbidReentrancy

inline fun <T> TlsBoxed<Boolean>.forbidReentrancy(action: () -> T): T

forEachReversed

inline fun <T> Array<out T>.forEachReversed(action: (T) -> Unit)

get

operator fun <T> BitSlice.TypedBitSlice<T>.get(host: AtomicInteger): T

getLogger

inline fun <T> getLogger(): Logger

fun getLogger(category: String): SwitchLogger

fun getLogger(categoryKclass: KClass<*>): Logger

getOrCreate

inline fun <K : Any, V : Any> MutableMap<K, V>.getOrCreate(key: K, crossinline creator: (K) -> V): V

getThrowableText

fun Throwable.getThrowableText(): String

info

inline fun Logger.info(msg: () -> Any?)

insert

inline fun <T> Array<T>.insert(elt: T, idx: Int): Array<T>

keySet

fun <K, V> MutableMap<K, V>.keySet(value: V): MutableSet<K>

log

inline fun Logger.log(level: LogLevel, msg: () -> Any?)

log2ceil

fun log2ceil(value: Int): Int

measureTimeMillis

fun measureTimeMillis(block: () -> Unit): Long

nextSliceLow

fun BitSlice?.nextSliceLow(): Int

parseFromFlags

inline fun <T : Enum<T>> parseFromFlags(flags: Int): EnumSet<T>

parseFromOrdinal

inline fun <T : Enum<T>> parseFromOrdinal(ordinal: Int): T

parseLong

fun ByteArray.parseLong(offset: Int): Long

printlnError

fun printlnError(msg: String)

put

fun <K, V> MutableMap<K, V>.put(entry: Map.Entry<K, V>): V?

fun <K, V> MutableMap<K, V>.put(lf: Lifetime, key: K, value: V)

putLong

fun ByteArray.putLong(long: Long, offset: Int)

putUnique

fun <K, V> MutableMap<K, V>.putUnique(key: K, value: V): V

qualifiedName

fun qualifiedName(kclass: KClass<*>): String

remove

inline fun <T> Array<T>.remove(elt: T): Array<T>

restOrNull

fun <T> List<T>?.restOrNull(): List<T>?

spinUntil

inline fun spinUntil(condition: () -> Boolean)

inline fun spinUntil(timeoutMs: Long, condition: () -> Boolean): Boolean

threadLocalWithInitial

fun <T> threadLocalWithInitial(initial: () -> T): ThreadLocal<T>

throttleLast

fun <T : Any> ISource<T>.throttleLast(timeout: Duration, scheduler: IScheduler): ISource<T>

trace

inline fun Logger.trace(msg: () -> Any?)

use

inline fun <T : Closeable?, R> T.use(block: (T) -> R): R

values

fun <T : Enum<T>> EnumSet<T>.values(): Set<T>

warn

inline fun Logger.warn(msg: () -> Any?)