fluid-stdlib/io.fluidsonic.stdlib

Package-level declarations

Types

AttributedString

class AttributedString : CharSequence

Base62

object Base62

GeoCoordinate

data class GeoCoordinate(val latitude: Double, val longitude: Double)

GeoPolygon

data class GeoPolygon(val points: List<GeoCoordinate>)

HalfOpenIntRange

class HalfOpenIntRange(start: Int, endExclusive: Int) : HalfOpenRange<Int> , Iterable<Int>

HalfOpenRange

interface HalfOpenRange<Bound : Comparable<Bound>>

Maybe

class Maybe<out Value>

MutableStringAttributeMap

interface MutableStringAttributeMap : StringAttributeMap

SemanticVersion

data class SemanticVersion(val major: Int, val minor: Int = 0, val patch: Int = 0) : Comparable<SemanticVersion>

StringAttribute

interface StringAttribute<Value : Any>

StringAttributeMap

interface StringAttributeMap

Properties

isInteger

val BigDecimal.isInteger: Boolean

isZero

val BigDecimal.isZero: Boolean

unicodeLength

val String.unicodeLength: Int

Functions

buildAttributedString

fun buildAttributedString(builderAction: AttributedString.Builder.() -> Unit): AttributedString

fun buildAttributedString(string: String, builderAction: AttributedString.Builder.() -> Unit): AttributedString

cast

inline fun <T : Any> Any.~~cast~~(): T

castOrNull

inline fun <T : Any> Any.~~castOrNull~~(): T?

check

inline fun <Value : Comparable<Value>> check(value: Value, inRange: ClosedRange<Value>, name: String)

inline fun check(value: Int, inRange: IntRange, name: String)

inline fun check(value: Int, inRange: LongRange, name: String)

inline fun check(value: Long, inRange: IntRange, name: String)

inline fun check(value: Long, inRange: LongRange, name: String)

component1

operator fun CharRange.component1(): Char

@JvmName(name = "component1Double")

operator fun ClosedFloatingPointRange<Double>.component1(): Double

@JvmName(name = "component1Float")

operator fun ClosedFloatingPointRange<Float>.component1(): Float

operator fun <Bound : Comparable<Bound>> ClosedRange<Bound>.component1(): Bound

operator fun IntRange.component1(): Int

operator fun LongRange.component1(): Long

operator fun UIntRange.component1(): UInt

operator fun ULongRange.component1(): ULong

component2

operator fun CharRange.component2(): Char

@JvmName(name = "component2Double")

operator fun ClosedFloatingPointRange<Double>.component2(): Double

@JvmName(name = "component2Float")

operator fun ClosedFloatingPointRange<Float>.component2(): Float

operator fun <Bound : Comparable<Bound>> ClosedRange<Bound>.component2(): Bound

operator fun IntRange.component2(): Int

operator fun LongRange.component2(): Long

operator fun UIntRange.component2(): UInt

operator fun ULongRange.component2(): ULong

contains

fun HalfOpenIntRange.contains(other: HalfOpenIntRange): Boolean

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.contains(other: HalfOpenRange<Bound>): Boolean

dropFirst

fun <Element> List<Element>.dropFirst(): List<Element>

dropLast

fun <Element> List<Element>.dropLast(): List<Element>

emptyStringAttributes

fun emptyStringAttributes(): StringAttributeMap

flipped

fun HalfOpenIntRange.flipped(): HalfOpenIntRange

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.flipped(): HalfOpenRange<Bound>

fun CharRange.flipped(): CharRange

@JvmName(name = "flippedDouble")

fun ClosedFloatingPointRange<Double>.flipped(): ClosedFloatingPointRange<Double>

@JvmName(name = "flippedFloat")

fun ClosedFloatingPointRange<Float>.flipped(): ClosedFloatingPointRange<Float>

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.flipped(): ClosedRange<Bound>

fun IntRange.flipped(): IntRange

fun LongRange.flipped(): LongRange

fun UIntRange.flipped(): UIntRange

fun ULongRange.flipped(): ULongRange

get

inline operator fun <Attribute : StringAttribute<out Value>, Value : Any> StringAttributeMap.get(attribute: Attribute): Value?

getOrElse

inline fun <Value> Maybe<Value>.getOrElse(default: () -> Value): Value

identity

fun <T> identity(value: T): T

ifFalse

inline fun Boolean.ifFalse(block: () -> Boolean): Boolean

ifNull

inline fun <T : Any> T?.ifNull(defaultValue: () -> T): T

ifTrue

inline fun Boolean.ifTrue(block: () -> Boolean): Boolean

intersection

fun HalfOpenIntRange.intersection(other: HalfOpenIntRange): HalfOpenIntRange?

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.intersection(other: HalfOpenRange<Bound>): HalfOpenRange<Bound>?

fun CharRange.intersection(other: CharRange): HalfOpenRange<Char>?

@JvmName(name = "intersectionDouble")

fun ClosedFloatingPointRange<Double>.intersection(other: ClosedFloatingPointRange<Double>): HalfOpenRange<Double>?

@JvmName(name = "intersectionFloat")

fun ClosedFloatingPointRange<Float>.intersection(other: ClosedFloatingPointRange<Float>): HalfOpenRange<Float>?

fun IntRange.intersection(other: IntRange): HalfOpenIntRange?

fun LongRange.intersection(other: LongRange): HalfOpenRange<Long>?

fun UIntRange.intersection(other: UIntRange): HalfOpenRange<UInt>?

fun ULongRange.intersection(other: ULongRange): HalfOpenRange<ULong>?

intersects

fun <Element> Set<Element>.intersects(other: Set<Element>): Boolean

isNotEmpty

fun StringAttributeMap.isNotEmpty(): Boolean

mapBounds

inline fun <R : Comparable<R>> HalfOpenIntRange.mapBounds(transform: (Int) -> R): HalfOpenRange<R>

inline fun HalfOpenIntRange.mapBounds(transform: (Int) -> Int): HalfOpenIntRange

inline fun <Bound : Comparable<Bound>, R : Comparable<R>> HalfOpenRange<Bound>.mapBounds(transform: (Bound) -> R): HalfOpenRange<R>

inline fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.mapBounds(transform: (Bound) -> Int): HalfOpenIntRange

fun <R : Comparable<R>> CharRange.mapBounds(transform: (Char) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun CharRange.mapBounds(transform: (Char) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun CharRange.mapBounds(transform: (Char) -> Float): ClosedFloatingPointRange<Float>

fun CharRange.mapBounds(transform: (Char) -> Int): IntRange

fun CharRange.mapBounds(transform: (Char) -> Long): LongRange

fun CharRange.mapBounds(transform: (Char) -> UInt): UIntRange

fun CharRange.mapBounds(transform: (Char) -> ULong): ULongRange

@JvmName(name = "mapDoubleBounds")

fun <R : Comparable<R>> ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> R): ClosedRange<R>

@JvmName(name = "mapDoubleBoundsToDouble")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapDoubleBoundsToFloat")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> Float): ClosedFloatingPointRange<Float>

@JvmName(name = "mapDoubleBounds")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> Int): IntRange

@JvmName(name = "mapDoubleBounds")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> Long): LongRange

@JvmName(name = "mapDoubleBounds")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> UInt): UIntRange

@JvmName(name = "mapDoubleBounds")

fun ClosedFloatingPointRange<Double>.mapBounds(transform: (Double) -> ULong): ULongRange

@JvmName(name = "mapFloatBounds")

fun <R : Comparable<R>> ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> R): ClosedRange<R>

@JvmName(name = "mapFloatBoundsToDouble")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapFloatBoundsToFloat")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> Float): ClosedFloatingPointRange<Float>

@JvmName(name = "mapFloatBounds")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> Int): IntRange

@JvmName(name = "mapFloatBounds")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> Long): LongRange

@JvmName(name = "mapFloatBounds")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> UInt): UIntRange

@JvmName(name = "mapFloatBounds")

fun ClosedFloatingPointRange<Float>.mapBounds(transform: (Float) -> ULong): ULongRange

fun <Bound : Comparable<Bound>, R : Comparable<R>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> Float): ClosedFloatingPointRange<Float>

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> Int): IntRange

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> Long): LongRange

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.mapBounds(transform: (Bound) -> UInt): UIntRange

fun <R : Comparable<R>> IntRange.mapBounds(transform: (Int) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun IntRange.mapBounds(transform: (Int) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun IntRange.mapBounds(transform: (Int) -> Float): ClosedFloatingPointRange<Float>

fun IntRange.mapBounds(transform: (Int) -> Int): IntRange

fun IntRange.mapBounds(transform: (Int) -> Long): LongRange

fun IntRange.mapBounds(transform: (Int) -> UInt): UIntRange

fun IntRange.mapBounds(transform: (Int) -> ULong): ULongRange

fun <R : Comparable<R>> LongRange.mapBounds(transform: (Long) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun LongRange.mapBounds(transform: (Long) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun LongRange.mapBounds(transform: (Long) -> Float): ClosedFloatingPointRange<Float>

fun LongRange.mapBounds(transform: (Long) -> Int): IntRange

fun LongRange.mapBounds(transform: (Long) -> Long): LongRange

fun LongRange.mapBounds(transform: (Long) -> UInt): UIntRange

fun LongRange.mapBounds(transform: (Long) -> ULong): ULongRange

fun <R : Comparable<R>> UIntRange.mapBounds(transform: (UInt) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun UIntRange.mapBounds(transform: (UInt) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun UIntRange.mapBounds(transform: (UInt) -> Float): ClosedFloatingPointRange<Float>

fun UIntRange.mapBounds(transform: (UInt) -> Int): IntRange

fun UIntRange.mapBounds(transform: (UInt) -> Long): LongRange

fun UIntRange.mapBounds(transform: (UInt) -> UInt): UIntRange

fun UIntRange.mapBounds(transform: (UInt) -> ULong): ULongRange

fun <R : Comparable<R>> ULongRange.mapBounds(transform: (ULong) -> R): ClosedRange<R>

@JvmName(name = "mapBoundsToDouble")

fun ULongRange.mapBounds(transform: (ULong) -> Double): ClosedFloatingPointRange<Double>

@JvmName(name = "mapBoundsToFloat")

fun ULongRange.mapBounds(transform: (ULong) -> Float): ClosedFloatingPointRange<Float>

fun ULongRange.mapBounds(transform: (ULong) -> Int): IntRange

fun ULongRange.mapBounds(transform: (ULong) -> Long): LongRange

fun ULongRange.mapBounds(transform: (ULong) -> UInt): UIntRange

fun ULongRange.mapBounds(transform: (ULong) -> ULong): ULongRange

mapIfNotNull

inline fun <Value : Any, TransformedValue> Maybe<Value?>.mapIfNotNull(mapping: (Value) -> TransformedValue?): Maybe<TransformedValue?>

mutableStringAttributesOf

fun mutableStringAttributesOf(): MutableStringAttributeMap

fun mutableStringAttributesOf(vararg pairs: Pair<StringAttribute<*>, Any>): MutableStringAttributeMap

fun mutableStringAttributesOf(pair: Pair<StringAttribute<*>, Any>): MutableStringAttributeMap

overlaps

fun HalfOpenIntRange.overlaps(other: HalfOpenIntRange): Boolean

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.overlaps(other: HalfOpenRange<Bound>): Boolean

fun CharRange.overlaps(other: CharRange): Boolean

@JvmName(name = "overlapsDouble")

fun ClosedFloatingPointRange<Double>.overlaps(other: ClosedFloatingPointRange<Double>): Boolean

@JvmName(name = "overlapsFloat")

fun ClosedFloatingPointRange<Float>.overlaps(other: ClosedFloatingPointRange<Float>): Boolean

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.overlaps(other: ClosedRange<Bound>): Boolean

fun IntRange.overlaps(other: IntRange): Boolean

fun LongRange.overlaps(other: LongRange): Boolean

fun UIntRange.overlaps(other: UIntRange): Boolean

fun ULongRange.overlaps(other: ULongRange): Boolean

put

fun MutableStringAttributeMap.put(pair: Pair<StringAttribute<*>, Any>): Any?

putAll

fun MutableStringAttributeMap.putAll(pairs: Array<Pair<StringAttribute<*>, Any>>)

fun MutableStringAttributeMap.putAll(pairs: Iterable<Pair<StringAttribute<*>, Any>>)

fun MutableStringAttributeMap.putAll(pairs: Sequence<Pair<StringAttribute<*>, Any>>)

rangeToExcluding

infix fun <Bound : Comparable<Bound>> Bound.rangeToExcluding(that: Bound): HalfOpenRange<Bound>

infix fun Int.rangeToExcluding(that: Int): HalfOpenIntRange

removeAttributes

fun MutableStringAttributeMap.removeAttributes(attributes: Array<StringAttribute<*>>)

fun MutableStringAttributeMap.removeAttributes(attributes: Iterable<StringAttribute<*>>)

fun MutableStringAttributeMap.removeAttributes(attributes: Sequence<StringAttribute<*>>)

set

inline operator fun <Attribute : StringAttribute<out Value>, Value : Any> MutableStringAttributeMap.set(attribute: Attribute, value: Value): Value?

stackTrace

fun stackTrace(skipCount: Int = 0): List<StackTraceElement>

stringAttributesOf

fun stringAttributesOf(): StringAttributeMap

fun stringAttributesOf(vararg pairs: Pair<StringAttribute<*>, Any>): StringAttributeMap

fun stringAttributesOf(pair: Pair<StringAttribute<*>, Any>): StringAttributeMap

subtracting

fun HalfOpenIntRange.subtracting(rangeToSubtract: HalfOpenIntRange): List<HalfOpenIntRange>

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.subtracting(rangeToSubtract: HalfOpenRange<Bound>): List<HalfOpenRange<Bound>>

thenTake

inline fun <Result> Boolean.thenTake(block: () -> Result): Result?

toAttributedString

fun String.toAttributedString(attributes: StringAttributeMap = emptyStringAttributes()): AttributedString

toAttributes

fun Array<out Pair<StringAttribute<*>, Any>>.toAttributes(): StringAttributeMap

fun Iterable<Pair<StringAttribute<*>, Any>>.toAttributes(): StringAttributeMap

fun Sequence<Pair<StringAttribute<*>, Any>>.toAttributes(): StringAttributeMap

toHashMap

fun <Key, Value> Map<Key, Value>.toHashMap(): HashMap<Key, Value>

toSequence

fun HalfOpenIntRange.toSequence(nextFunction: (Int) -> Int?): Sequence<Int>

fun <Bound : Comparable<Bound>> HalfOpenRange<Bound>.toSequence(nextFunction: (Bound) -> Bound?): Sequence<Bound>

fun <Bound : Comparable<Bound>> ClosedRange<Bound>.toSequence(next: (Bound) -> Bound?): Sequence<Bound>

truncatedTo

fun String.truncatedTo(maximumLength: Int, truncationSuffix: String = ""): String

unicodeSubstring

fun String.unicodeSubstring(startIndex: Int): String

fun String.unicodeSubstring(startIndex: Int, endIndex: Int): String

with

infix fun <Attribute : StringAttribute<Value>, Value : Any> Attribute.with(value: Value): Pair<Attribute, Value>