kone.relations/dev.lounres.kone.relations

Package-level declarations

Types

data class ClosedRange<out Element>(val start: Element, val endInclusive: Element)

A wrapper data class that contains values start and endInclusive to be used by ClosedRange.contains operator that checks if the provided value lies in a closed interval [start; endInclusive].

Comparator

fun interface Comparator<in Element>

Provides comparison of two elements. Alternative of Kotlin stlib Comparator but with result of type ComparisonResult.

ComparisonResult

enum ComparisonResult : Enum<ComparisonResult>

Describes result of two elements comparison. See Order for the main application.

Equality

interface Equality<in Element> : KoneContext

Describes a context that provides equality equivalence relation on the set of elements of type Element (or some subdomain). The relation is described by equalsTo function.

Hashing

interface Hashing<in Element> : KoneContext

Describes a context that provides hash operator besides inherited coincidesWith operator. This operator should return the same value for elements that are equal according to coincidesWith operator.

Order

interface Order<in Element> : KoneContext

Describes a context that provides linear (total) order as a compareTo.

Reification

interface Reification<out Element> : KoneContext

Describes a context that checks if the element lays in specific domain. It is usually used in pair with contexts like Equality, Order, or Hashing to check that the element lays in the second context's domain.

ReificationException

class ReificationException(message: String) : RuntimeException

Describes that element was forcefully (via Reification.reify) checked on lying in the domain, and the check was unsuccessful.

RightOpenRange

data class RightOpenRange<out Element>(val start: Element, val endExclusive: Element)

A wrapper data class that contains values start and endExclusive to be used by RightOpenRange.contains operator that checks if the provided value lies in a right-open interval [start; endExclusive).

Properties

comparator

val <Element> comparator: Comparator<Element>

Functions

absoluteEquality

fun <Element> absoluteEquality(): Equality<Element>

Returns Equality instance which Equality.equalsTo operator just uses absolute equality === operator's result as a return value.

asComparator

fun <Element> Order<Element>.asComparator(): Comparator<Element>

Converts provided Order receiver into Comparator that delegates its Comparator.compare operator to Order.compareTo operator.

asComparisonResult

fun Int.asComparisonResult(): ComparisonResult

Shortcut to convert comparison result from Comparable's and Kotlin stlib Comparator's terms to Order's and Kone Comparator's terms.

asKone

fun <Element> Comparator<Element>.asKone(): Comparator<Element>

Converts Kotlin stlib Comparator to Kone Comparator.

asKotlinComparisonResult

fun ComparisonResult.asKotlinComparisonResult(): Int

Shortcut to convert comparison result from Comparable's and Order's terms to Kotlin stlib Comparator's and Kone Comparator's terms.

asKotlinStdlib

fun <Element> Comparator<Element>.asKotlinStdlib(): Comparator<Element>

Converts Kone Comparator to Kotlin stlib Comparator.

coincidesWith

infix inline fun <Element> Element.coincidesWith(other: Element): Boolean

compareByOrdered

fun <Target, Element> compareByOrdered(vararg selectors: (Target) -> Element): Comparator<Target>

compareTo

operator fun <Element> Element.compareTo(other: Element): Int

compareWith

infix fun <Element> Element.compareWith(other: Element): ComparisonResult

contains

operator fun <Element> ClosedRange<Element>.contains(element: Element): Boolean

operator fun <Element> RightOpenRange<Element>.contains(element: Element): Boolean

defaultComparator

inline fun <Element : Comparable<Element>> defaultComparator(): Comparator<Element>

Returns Comparator instance which Comparator.compare operator just uses Comparable.compareTo operator's result as a return value.

defaultEquality

fun <Element> defaultEquality(): Equality<Element>

Returns Equality instance which Equality.equalsTo operator just uses Any.equals operator's result as a return value.

defaultHashing

fun <Element> defaultHashing(): Hashing<Element>

Returns Hashing instance which Equality.coincidesWith operator just uses Any.equals operator's result as a return value and which Hashing.hash operator just uses Any.hashCode operator's result as a return value.

defaultOrder

fun <Element : Comparable<Element>> defaultOrder(): Order<Element>

Returns Order instance which Order.compareTo operator just uses Comparable.compareTo operator's result as a return value.

infix inline fun <Element> Element.eq(other: Element): Boolean

Equality

inline fun <Element> Equality(crossinline equalizer: (left: Element, right: Element) -> Boolean): Equality<Element>

Equality builder from an equalizer that checks equality of the left and right elements.

equalsTo

infix inline fun <Element> Element.equalsTo(other: Element): Boolean

geq

infix inline fun <Element> Element.geq(other: Element): Boolean

greaterThan

infix inline fun <Element> Element.greaterThan(other: Element): Boolean

greaterThanOrEqual

infix inline fun <Element> Element.greaterThanOrEqual(other: Element): Boolean

infix inline fun <Element> Element.gt(other: Element): Boolean

hash

fun <Element> Element.hash(): Int

Hashing

inline fun <Element> Hashing(crossinline hasher: (Element) -> Int): Hashing<Element>

Hashing builder from a hasher that computes hash of provided element.

installAbsoluteEqualityFor

fun <Element> KoneContextRegistryBuilder.installAbsoluteEqualityFor(suppliedElementType: SuppliedType<Element>)

Installs absolute Equality context for the given suppliedElementType into context registry builder.

installDefaultEqualityFor

fun <Element> KoneContextRegistryBuilder.installDefaultEqualityFor(suppliedElementType: SuppliedType<Element>)

Installs default Equality context for the given suppliedElementType into context registry builder.

installDefaultHashingFor

fun <Element> KoneContextRegistryBuilder.installDefaultHashingFor(suppliedElementType: SuppliedType<Element>)

Installs default Hashing context for the given suppliedElementType into context registry builder.

installReificationFor

inline fun <Element> KoneContextRegistryBuilder.installReificationFor(suppliedElementType: SuppliedType<Element>)

Installs Reification context for the given suppliedElementType into context registry builder. The installed reification just only checks that the element is of type Element.

leq

infix inline fun <Element> Element.leq(other: Element): Boolean

lessThen

infix inline fun <Element> Element.lessThen(other: Element): Boolean

lessThenOrEqual

infix inline fun <Element> Element.lessThenOrEqual(other: Element): Boolean

loadEqualityFor

fun <Element> KoneContextRegistry.loadEqualityFor(suppliedElementType: SuppliedType<Element>): Equality<Element>

Shortcut for getting Equality context for the given suppliedElementType. Throws if there is no such context in the registry.

loadEqualityForOrDefault

fun <Element> KoneContextRegistry.loadEqualityForOrDefault(suppliedElementType: SuppliedType<Element>, default: Equality<Element>): Equality<Element>

Shortcut for getting Equality context for the given suppliedElementType or default context if there is no such context in the registry.

loadEqualityForOrElse

inline fun <Element> KoneContextRegistry.loadEqualityForOrElse(suppliedElementType: SuppliedType<Element>, block: () -> Equality<Element>): Equality<Element>

Shortcut for getting Equality context for the given suppliedElementType or compute block to get such context if there is no such context in the registry.

loadEqualityForOrNull

fun <Element> KoneContextRegistry.loadEqualityForOrNull(suppliedElementType: SuppliedType<Element>): Equality<Element>?

Shortcut for getting Equality context for the given suppliedElementType or null if there is no such context in the registry.

loadHashingFor

fun <Element> KoneContextRegistry.loadHashingFor(suppliedElementType: SuppliedType<Element>): Hashing<Element>

Shortcut for getting Hashing context for the given suppliedElementType. Throws if there is no such context in the registry.

loadHashingForOrDefault

fun <Element> KoneContextRegistry.loadHashingForOrDefault(suppliedElementType: SuppliedType<Element>, default: Hashing<Element>): Hashing<Element>

Shortcut for getting Hashing context for the given suppliedElementType or default context if there is no such context in the registry.

loadHashingForOrElse

inline fun <Element> KoneContextRegistry.loadHashingForOrElse(suppliedElementType: SuppliedType<Element>, block: () -> Hashing<Element>): Hashing<Element>

Shortcut for getting Hashing context for the given suppliedElementType or compute block to get such context if there is no such context in the registry.

loadHashingForOrNull

fun <Element> KoneContextRegistry.loadHashingForOrNull(suppliedElementType: SuppliedType<Element>): Hashing<Element>?

Shortcut for getting Hashing context for the given suppliedElementType or null if there is no such context in the registry.

loadOrderFor

fun <Element> KoneContextRegistry.loadOrderFor(suppliedElementType: SuppliedType<Element>): Order<Element>

Shortcut for getting Order context for the given suppliedElementType. Throws if there is no such context in the registry.

loadOrderForOrDefault

fun <Element> KoneContextRegistry.loadOrderForOrDefault(suppliedElementType: SuppliedType<Element>, default: Order<Element>): Order<Element>

Shortcut for getting Order context for the given suppliedElementType or default context if there is no such context in the registry.

loadOrderForOrElse

inline fun <Element> KoneContextRegistry.loadOrderForOrElse(suppliedElementType: SuppliedType<Element>, block: () -> Order<Element>): Order<Element>

Shortcut for getting Order context for the given suppliedElementType or compute block to get such context if there is no such context in the registry.

loadOrderForOrNull

fun <Element> KoneContextRegistry.loadOrderForOrNull(suppliedElementType: SuppliedType<Element>): Order<Element>?

Shortcut for getting Order context for the given suppliedElementType or null if there is no such context in the registry.

loadReificationFor

fun <Element> KoneContextRegistry.loadReificationFor(suppliedElementType: SuppliedType<Element>): Reification<Element>

Shortcut for getting Reification context for the given suppliedElementType. Throws if there is no such context in the registry.

loadReificationForOrDefault

fun <Element> KoneContextRegistry.loadReificationForOrDefault(suppliedElementType: SuppliedType<Element>, default: Reification<Element>): Reification<Element>

Shortcut for getting Reification context for the given suppliedElementType or default context if there is no such context in the registry.

loadReificationForOrElse

inline fun <Element> KoneContextRegistry.loadReificationForOrElse(suppliedElementType: SuppliedType<Element>, block: () -> Reification<Element>): Reification<Element>

Shortcut for getting Reification context for the given suppliedElementType or compute block to get such context if there is no such context in the registry.

loadReificationForOrNull

fun <Element> KoneContextRegistry.loadReificationForOrNull(suppliedElementType: SuppliedType<Element>): Reification<Element>?

Shortcut for getting Reification context for the given suppliedElementType or null if there is no such context in the registry.

infix inline fun <Element> Element.lt(other: Element): Boolean

max

fun <Element> max(vararg elements: Element): Element

fun <Element> max(a: Element, b: Element): Element

min

fun <Element> min(vararg elements: Element): Element

fun <Element> min(a: Element, b: Element): Element

neq

infix inline fun <Element> Element.neq(other: Element): Boolean

notCoincidesWith

infix inline fun <Element> Element.notCoincidesWith(other: Element): Boolean

notEqualsTo

infix inline fun <Element> Element.notEqualsTo(other: Element): Boolean

Order

inline fun <Element> Order(comparator: Comparator<Element>): Order<Element>

inline fun <Element> Order(crossinline comparator: (left: Element, right: Element) -> ComparisonResult): Order<Element>

Order builder from a comparator that compares the left and right elements to each other.

rangeTo

operator fun <Element> Element.rangeTo(other: Element): ClosedRange<Element>

Creates ClosedRange instance to be used by ClosedRange.contains operator that checks if the provided value lies in a closed interval from this to other.

rangeUntil

operator fun <Element> Element.rangeUntil(other: Element): RightOpenRange<Element>

Creates RightOpenRange instance to be used by RightOpenRange.contains operator that checks if the provided value lies in a right-open interval from this to other.

Reification