Package com.tomtom.sdk.common

Types

Callback

interface Callback<T, U>

Generic callback interface with a generic return types.

CallbackExecutor

interface CallbackExecutor

Generic contract for an executor of Runnable callbacks.

Cancellable

fun interface Cancellable

Represents a cancellable operation.

CompositeDisposable

class CompositeDisposable(disposable: Disposable) : Disposable

This composite allows grouping multiple Disposable into single structure and releasing them in one go. Note that Disposables will be disposed in reverse order that they were added.

Disposable

fun interface Disposable

Represents a disposable resource.

MainThreadCallbackExecutor

class MainThreadCallbackExecutor : CallbackExecutor

CallbackExecutor bound to the main thread of the application.

Result

sealed class Result<out SuccessType, out FailureType>

Class that represents the parse result which can be Success or Failure.

UniqueId

@JvmInline

value class UniqueId(val value: Long = nextValue.incrementAndGet())

Thread safe, single process 64 bit unique id. Not to be used if unique multi-process id generation is required.

Functions

bimap

inline fun <V, F, V2, F2> Result<V, F>.bimap(successMapper: (V) -> V2, failureMapper: (F) -> F2): Result<V2, F2>

Maps success value or failure.

flatMap

inline fun <V, F, V2> Result<V, F>.flatMap(mapper: (V) -> Result<V2, F>): Result<V2, F>

Maps success value to a new Result or passes failure.

fold

inline fun <V, F, R> Result<V, F>.fold(ifSuccess: (V) -> R, ifFailure: (F) -> R): R

Folds success or failure into a final value.

ifFailure

inline fun <V, F> Result<V, F>.ifFailure(ifFailure: (F) -> Unit): Result<V, F>

Performs provided operation if Result is failure.

ifSuccess

inline fun <V, F> Result<V, F>.ifSuccess(ifSuccess: (V) -> Unit): Result<V, F>

Performs provided operation if Result is success.

map

inline fun <V, F, V2> Result<V, F>.map(mapper: (V) -> V2): Result<V2, F>

Maps success value or passes failure.

mapFailure

inline fun <V, F, F2> Result<V, F>.mapFailure(mapper: (F) -> F2): Result<V, F2>

Maps failure or passes success value.

plusAssign

operator fun CompositeDisposable.plusAssign(disposable: Disposable)

Operator allowing adding disposable to composite like: compositeDisposable += disposable

toEither

fun <L, R> Result<R, L>.toEither(): Either<L, R>

Converts Result to Either. Result.Failure will be converted to Either.Left and Result.Success will be converted to Either.Right.

valueOr

inline fun <V, F> Result<V, F>.valueOr(handler: (F) -> V): V

Returns success value or uses handler to map failure to value.