org.atlanmod.commons.function

Interface Converter<T,R>

Type Parameters:

T - the type of the input to the converter

R - the type of the result of the converter

All Superinterfaces:

Function<T,R>

All Known Subinterfaces:

BinarySerializer<T>, Serializer<T,U>, StringSerializer<T>

All Known Implementing Classes:

AbstractBinarySerializer, AbstractStringSerializer

@ParametersAreNonnullByDefault
public interface Converter<T,R>
extends Function<T,R>

A specialized Function that converts an object of type T to another of type R.

The reverse operation may be strict inverse, meaning that converter.revert(converter.convert(a)).equals(a) always true.

See Also:

Function

Method Summary

Modifier and Type	Method and Description
default R	apply(T t)
static <T,U,R> Converter<T,R>	compose(Converter<T,U> before, Converter<U,R> after) Returns a composed converter that first applies the before function to its input, and then applies the after function to the result.
R	convert(T t) Returns a representation of t as an instance of type R.
static <T,R> Converter<T,R>	from(Function<? super T,? extends R> convertFunc, Function<? super R,? extends T> revertFunc) Creates a converter based on separate forward and backward functions.
static <T> Converter<T,T>	identity() Creates a converter that always converts or reverses an object to itself.
default Converter<R,T>	reverse() Returns the reversed converter of this converter.
T	revert(R r) Returns a representation of r as an instance of type T.

Methods inherited from interface java.util.function.Function

andThen, compose

Method Detail

identity

@Nonnull
static <T> Converter<T,T> identity()

Creates a converter that always converts or reverses an object to itself.

Specified by:

identity in interface Function<T,R>

Type Parameters:

T - the type of the converted instance and the result

Returns:

a new converter

from

@Nonnull
static <T,R> Converter<T,R> from(Function<? super T,? extends R> convertFunc,
                                          Function<? super R,? extends T> revertFunc)

Creates a converter based on separate forward and backward functions.

Type Parameters:

T - the type of the input to the converter

R - the type of the result of the converter

Parameters:

convertFunc - the function used for convert(Object)

revertFunc - the function used for revert(Object)

Returns:

a new converter

compose

@Nonnull
static <T,U,R> Converter<T,R> compose(Converter<T,U> before,
                                               Converter<U,R> after)

Returns a composed converter that first applies the before function to its input, and then applies the after function to the result. This behavior is inverted when calling revert(Object).

Type Parameters:

T - the type of input to the before converter, and to the composed function

U - the intermediate type

R - the type of output of the after converter, and of the composed function

Parameters:

before - the first converter

after - the second converter

Returns:

a composed converter

apply

default R apply(T t)

Specified by:

apply in interface Function<T,R>

convert

R convert(T t)

Returns a representation of t as an instance of type R.

Parameters:

t - the instance to convert

Returns:

the converted instance

revert

T revert(R r)

Returns a representation of r as an instance of type T.

Parameters:

r - the instance to convert

Returns:

the converted instance

reverse

@Nonnull
default Converter<R,T> reverse()

Returns the reversed converter of this converter.

Returns:

the reversed converter