hll-mapping-core/aws.sdk.kotlin.hll.mapping.core.converters/ConvertsFrom

ConvertsFrom

Models one-way conversion from a type T to a type F. This type is similar to ConvertsTo but models conversion in the opposite direction.

Parameters

The type being converted to

The type being converted from

Inheritors

Converter

SplittingConverter

Functions

convertFrom

abstract fun convertFrom(to: T): F

Converts a single value from type T to type F

Inherited functions

andThenConvertsFrom

fun <F, F2, T> ConvertsFrom<F, T>.andThenConvertsFrom(converter: ConvertsFrom<F2, F>): ConvertsFrom<F2, T>

Chains this converter with another converter, yielding a new converter which performs a two-stage conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)

firstValidatingTo

fun <F, T> ConvertsFrom<F, T>.firstValidatingTo(validate: (T) -> Unit): ConvertsFrom<F, T>

Adds validation before a conversion by running validate on T values before converting them to type F. Validators are expected to throw an exception if the expected condition is not met.

mapConvertsFrom

fun <F, F2, T> ConvertsFrom<List<F>, T>.mapConvertsFrom(elementConverter: ConvertsFrom<F2, F>): ConvertsFrom<List<F2>, T>

Chains this list converter with an element converter, yielding a new converter which performs a two-stage mapping conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)

fun <FK, FV, FK2, FV2, T> ConvertsFrom<Map<FK, FV>, T>.mapConvertsFrom(entryConverter: ConvertsFrom<Pair<FK2, FV2>, Pair<FK, FV>>): ConvertsFrom<Map<FK2, FV2>, T>

Chains this map converter with an entry converter, yielding a new converter which performs a two stage mapping conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)

fun <F, F2, T> ConvertsFrom<Set<F>, T>.mapConvertsFrom(elementConverter: ConvertsFrom<F2, F>): ConvertsFrom<Set<F2>, T>

Chains this set converter with an element converter, yielding a new converter which performs a two-stage mapping conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)

mapConvertsKeysFrom

fun <FK, FK2, V, T> ConvertsFrom<Map<FK, V>, T>.mapConvertsKeysFrom(keyConverter: ConvertsFrom<FK2, FK>): ConvertsFrom<Map<FK2, V>, T>

Chains this map converter with a key converter, yielding a new converter which performs a two-stage mapping conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)

mapConvertsValuesFrom

fun <K, FV, FV2, T> ConvertsFrom<Map<K, FV>, T>.mapConvertsValuesFrom(valueConverter: ConvertsFrom<FV2, FV>): ConvertsFrom<Map<K, FV2>, T>

Chains this map converter with a value converter, yielding a new converter which performs a two-stage mapping conversion. (Note that these two "stages" are conceptual. Each of these stages may consist of multiple logical steps in their actual implementation.)