Package-level declarations

A function type that allocates and returns a ByteArray.

Serializer for ByteArrayAllocator. Serializes the result of invoking the allocator.

Serializes DateTime as its raw DateTime.unixMillis and deserializes in the same way

Diff object which contains information about differences between two Iterables

Realization of this interface will contains at least one not null - optionalT1 or optionalT2

This type Either will always have not nullable optionalT1

This type Either will always have not nullable optionalT2

Contains diff based on the comparison of objects with the same K.

This type represents T as not only potentially nullable data, but also as a data which can not be presented. This type will be useful in cases when T is nullable and null as valuable data too in time of data absence should be presented by some third type.

Contains of1 as main value, where 100% of percentage is when of1 == 1

A bidirectional mapper that can convert between two types T1 and T2.

Implementation of SimpleMapper that uses lambda functions for conversion.

A bidirectional mapper that can convert between two types T1 and T2 using suspending functions.

Implementation of SimpleSuspendableMapper that uses suspending lambda functions for conversion.

A suspending function type that allocates and returns a ByteArray.

Converts this ByteArray to a ByteArrayAllocator that returns this array.

Converts this ByteArray to a SuspendByteArrayAllocator that returns this array.

Converts this ByteArrayAllocator to a SuspendByteArrayAllocator.

Executes the given block if this Boolean is false and returns this Boolean. Similar to also, but only executes the block when the Boolean is false.

Executes the given block if this Boolean is true and returns this Boolean. Similar to also, but only executes the block when the Boolean is true.

Applies diff to this

Will apply mapDiff to this

This method call calculateDiff with strict mode strictComparison and then apply differences to this mutable list

This method call calculateDiff and then apply differences to this mutable list

Will apply changes with from map into this one

Converts this SuspendByteArrayAllocator to a ByteArrayAllocator by invoking it and wrapping the result in a non-suspending allocator.

Breaks this list into a list of consecutive pairs. Each element is paired with the next element in the list. For a list of size n, the result will contain n-1 pairs.

Calculating Diff object

This method call calculateDiff with strict mode enabled

Converts from of type T2 to type T1 using this mapper.

Converts from of type T1 to type T2 using this mapper.

Converts from of type T2 to type T1 using this suspending mapper.

Converts from of type T1 to type T2 using this suspending mapper.

Creates simple Comparator which will use compareTo of T for both objects

Returns Optional.data if Optional.dataPresented of this is true, or call block and returns the result of it

Returns Optional.data if Optional.dataPresented of this is true, or null otherwise

Returns Optional.data if Optional.dataPresented of this is true, or throw throwable otherwise

Compare this with the other one in principle when other is newer than this

Will return this if Percentage.of1 in 0 .. 1 range

Will return this if Percentage.of1 in 0 .. 1 range. Otherwise, will throw error IllegalArgumentException due to require failure

Returns the first non-null element in this iterable.

Alias for letIfFalse. Executes the given block and returns its result if this Boolean is false.

Alias for letIfTrue. Executes the given block and returns its result if this Boolean is true.

Computes the intersection of this range with other. Returns a pair representing the intersecting range, or null if the ranges don't overlap.

Computes the intersection of this IntRange with other. Returns the intersecting range, or null if the ranges don't overlap.

Computes the intersection of this LongRange with other. Returns the intersecting range, or null if the ranges don't overlap.

Joins elements of this iterable into a list with a constant separator between elements. Optional prefix and postfix can be added to the result. Null separators are skipped.

Joins elements of this iterable into a list with separators between elements. Separators are generated using separatorFun. Optional prefix and postfix can be added to the result. Null values from separator function are skipped.

Joins elements of this array into an array with a constant separator between elements. Each element is transformed using transform. Optional prefix and postfix can be added to the result. Null values from transformations or separators are skipped.

Joins elements of this array into an array with separators between elements. Each element is transformed using transform, and separators are generated using separatorFun. Optional prefix and postfix can be added to the result. Null values from transformations or separator function are skipped.

Joins elements of this iterable into a list with a constant separator between elements. Each element is transformed using transform. Optional prefix and postfix can be added to the result. Null values from transformations or separators are skipped.

Joins elements of this iterable into a list with separators between elements. Each element is transformed using transform, and separators are generated using separatorFun. Optional prefix and postfix can be added to the result. Null values from transformations or separator function are skipped.

Executes the given block and returns its result if this Boolean is false, otherwise returns null.

Executes the given block and returns its result if this Boolean is true, otherwise returns null.

Will call block when data presented (Optional.dataPresented == true)

Will call block when data presented (Optional.dataPresented == true)

Will call block when data absent (Optional.dataPresented == false)

Will call block in case when this is EitherFirst

Will call block when data presented (Optional.dataPresented == true)

Will call block in case when this is EitherSecond

Pads this list at the end to the specified size using the given element o.

Pads this list at the end to the specified size. New elements are generated using padBlock, which receives the current size as a parameter.

Pads this sequence at the end to the specified size using the given element o.

Pads this sequence at the end to the specified size. New elements are generated using padBlock, which receives the current size as a parameter.

Pads this list at the start to the specified size using the given element o.

Pads this list at the start to the specified size. New elements are generated using padBlock, which receives the current size as a parameter.

Pads this sequence at the start to the specified size using the given element o.

Pads this sequence at the start to the specified size. New elements are generated using padBlock, which receives the current size as a parameter.

Pads this list to the specified size using a custom inserter function. The inserter is repeatedly called until the list reaches the desired size.

Pads this sequence to the specified size using a custom inserter function. The inserter is repeatedly called until the sequence reaches the desired size.

Executes the given action until getting of successful result specified number of times.

Executes the given action until getting of successful result specified number of times.

Will try to execute action and, if any exception will happen, execution will be retried. This process will happen at most count times. There is no any limits on count value, but action will run at least once and retryOnFailure will return its result if it is successful

Reverse this. Result will contain Diff.added on Diff.removed (and vice-verse), all the Diff.replaced values will be reversed too

Reverse this. Result will contain MapDiff.added on MapDiff.removed (and vice-verse), all the MapDiff.changed values will be reversed too