org.seedstack.business.assembler.dsl

Interface MergeAggregateOrTupleProvider<D>

Type Parameters:

D - the DTO type

All Known Subinterfaces:

MergeAggregateOrTupleWithQualifierProvider<D>

public interface MergeAggregateOrTupleProvider<D>

Specifies the target aggregate to merge.

Author:

pierre.thirouin@ext.mpsa.com (Pierre Thirouin)

Method Summary

Modifier and Type	Method and Description
<A extends AggregateRoot<?>> void	into(A aggregateRoot) Merges the dto to an aggregate root.
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>> void	into(A1 first, A2 second) Merges the dto to a pair of aggregate roots.
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth, A6 sixth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth, A6 sixth, A7 seventh)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth, A6 sixth, A7 seventh, A8 eighth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth, A6 sixth, A7 seventh, A8 eighth, A9 ninth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>,A10 extends AggregateRoot<?>> void	into(A1 first, A2 second, A3 third, A4 fourth, A5 fifth, A6 sixth, A7 seventh, A8 eighth, A9 ninth, A10 tenth)
<A extends AggregateRoot<?>> MergeAggregateWithRepositoryProvider<A>	into(Class<A> aggregateRootClass) Merges the dto to an aggregate root.
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Pair<A1,A2>>	into(Class<A1> first, Class<A2> second)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Triplet<A1,A2,A3>>	into(Class<A1> first, Class<A2> second, Class<A3> third)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Quartet<A1,A2,A3,A4>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Quintet<A1,A2,A3,A4,A5>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Sextet<A1,A2,A3,A4,A5,A6>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth, Class<A6> sixth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Septet<A1,A2,A3,A4,A5,A6,A7>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth, Class<A6> sixth, Class<A7> seventh)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Octet<A1,A2,A3,A4,A5,A6,A7,A8>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth, Class<A6> sixth, Class<A7> seventh, Class<A8> eighth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Ennead<A1,A2,A3,A4,A5,A6,A7,A8,A9>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth, Class<A6> sixth, Class<A7> seventh, Class<A8> eighth, Class<A9> ninth)
<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>,A10 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Decade<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>>	into(Class<A1> first, Class<A2> second, Class<A3> third, Class<A4> fourth, Class<A5> fifth, Class<A6> sixth, Class<A7> seventh, Class<A8> eighth, Class<A9> ninth, Class<A10> tenth)
MergeTupleWithRepositoryProvider<org.javatuples.Tuple>	into(List<Class<? extends AggregateRoot<?>>> aggregateRootClasses) Merge the dto into a tuple of aggregate roots.
void	into(org.javatuples.Tuple aggregateRoots) Deprecated.

Method Detail

into

<A extends AggregateRoot<?>> void into(A aggregateRoot)

Merges the dto to an aggregate root.

Type Parameters:

A - the aggregate root type

Parameters:

aggregateRoot - the aggregate root instance

into

<A extends AggregateRoot<?>> MergeAggregateWithRepositoryProvider<A> into(Class<A> aggregateRootClass)

Merges the dto to an aggregate root.

Type Parameters:

A - the type of aggregate root

Parameters:

aggregateRootClass - the aggregate root class

Returns:

the assembler DSL to assemble an aggregate root

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>> void into(A1 first,
                                                                    A2 second)

Merges the dto to a pair of aggregate roots.

Type Parameters:

A1 - the first aggregate root type

A2 - the second aggregate root type

Parameters:

first - the first aggregate root of the pair

second - the second aggregate root of the pair

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>> void into(A1 first,
                                                                                                A2 second,
                                                                                                A3 third)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                            A2 second,
                                                                                                                            A3 third,
                                                                                                                            A4 fourth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                        A2 second,
                                                                                                                                                        A3 third,
                                                                                                                                                        A4 fourth,
                                                                                                                                                        A5 fifth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                                                    A2 second,
                                                                                                                                                                                    A3 third,
                                                                                                                                                                                    A4 fourth,
                                                                                                                                                                                    A5 fifth,
                                                                                                                                                                                    A6 sixth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                                                                                A2 second,
                                                                                                                                                                                                                A3 third,
                                                                                                                                                                                                                A4 fourth,
                                                                                                                                                                                                                A5 fifth,
                                                                                                                                                                                                                A6 sixth,
                                                                                                                                                                                                                A7 seventh)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                                                                                                            A2 second,
                                                                                                                                                                                                                                            A3 third,
                                                                                                                                                                                                                                            A4 fourth,
                                                                                                                                                                                                                                            A5 fifth,
                                                                                                                                                                                                                                            A6 sixth,
                                                                                                                                                                                                                                            A7 seventh,
                                                                                                                                                                                                                                            A8 eighth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                                                                                                                                        A2 second,
                                                                                                                                                                                                                                                                        A3 third,
                                                                                                                                                                                                                                                                        A4 fourth,
                                                                                                                                                                                                                                                                        A5 fifth,
                                                                                                                                                                                                                                                                        A6 sixth,
                                                                                                                                                                                                                                                                        A7 seventh,
                                                                                                                                                                                                                                                                        A8 eighth,
                                                                                                                                                                                                                                                                        A9 ninth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>,A10 extends AggregateRoot<?>> void into(A1 first,
                                                                                                                                                                                                                                                                                                     A2 second,
                                                                                                                                                                                                                                                                                                     A3 third,
                                                                                                                                                                                                                                                                                                     A4 fourth,
                                                                                                                                                                                                                                                                                                     A5 fifth,
                                                                                                                                                                                                                                                                                                     A6 sixth,
                                                                                                                                                                                                                                                                                                     A7 seventh,
                                                                                                                                                                                                                                                                                                     A8 eighth,
                                                                                                                                                                                                                                                                                                     A9 ninth,
                                                                                                                                                                                                                                                                                                     A10 tenth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Pair<A1,A2>> into(Class<A1> first,
                                                                                                                            Class<A2> second)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Triplet<A1,A2,A3>> into(Class<A1> first,
                                                                                                                                                              Class<A2> second,
                                                                                                                                                              Class<A3> third)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Quartet<A1,A2,A3,A4>> into(Class<A1> first,
                                                                                                                                                                                             Class<A2> second,
                                                                                                                                                                                             Class<A3> third,
                                                                                                                                                                                             Class<A4> fourth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Quintet<A1,A2,A3,A4,A5>> into(Class<A1> first,
                                                                                                                                                                                                                            Class<A2> second,
                                                                                                                                                                                                                            Class<A3> third,
                                                                                                                                                                                                                            Class<A4> fourth,
                                                                                                                                                                                                                            Class<A5> fifth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Sextet<A1,A2,A3,A4,A5,A6>> into(Class<A1> first,
                                                                                                                                                                                                                                                          Class<A2> second,
                                                                                                                                                                                                                                                          Class<A3> third,
                                                                                                                                                                                                                                                          Class<A4> fourth,
                                                                                                                                                                                                                                                          Class<A5> fifth,
                                                                                                                                                                                                                                                          Class<A6> sixth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Septet<A1,A2,A3,A4,A5,A6,A7>> into(Class<A1> first,
                                                                                                                                                                                                                                                                                         Class<A2> second,
                                                                                                                                                                                                                                                                                         Class<A3> third,
                                                                                                                                                                                                                                                                                         Class<A4> fourth,
                                                                                                                                                                                                                                                                                         Class<A5> fifth,
                                                                                                                                                                                                                                                                                         Class<A6> sixth,
                                                                                                                                                                                                                                                                                         Class<A7> seventh)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Octet<A1,A2,A3,A4,A5,A6,A7,A8>> into(Class<A1> first,
                                                                                                                                                                                                                                                                                                                       Class<A2> second,
                                                                                                                                                                                                                                                                                                                       Class<A3> third,
                                                                                                                                                                                                                                                                                                                       Class<A4> fourth,
                                                                                                                                                                                                                                                                                                                       Class<A5> fifth,
                                                                                                                                                                                                                                                                                                                       Class<A6> sixth,
                                                                                                                                                                                                                                                                                                                       Class<A7> seventh,
                                                                                                                                                                                                                                                                                                                       Class<A8> eighth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Ennead<A1,A2,A3,A4,A5,A6,A7,A8,A9>> into(Class<A1> first,
                                                                                                                                                                                                                                                                                                                                                       Class<A2> second,
                                                                                                                                                                                                                                                                                                                                                       Class<A3> third,
                                                                                                                                                                                                                                                                                                                                                       Class<A4> fourth,
                                                                                                                                                                                                                                                                                                                                                       Class<A5> fifth,
                                                                                                                                                                                                                                                                                                                                                       Class<A6> sixth,
                                                                                                                                                                                                                                                                                                                                                       Class<A7> seventh,
                                                                                                                                                                                                                                                                                                                                                       Class<A8> eighth,
                                                                                                                                                                                                                                                                                                                                                       Class<A9> ninth)

into

<A1 extends AggregateRoot<?>,A2 extends AggregateRoot<?>,A3 extends AggregateRoot<?>,A4 extends AggregateRoot<?>,A5 extends AggregateRoot<?>,A6 extends AggregateRoot<?>,A7 extends AggregateRoot<?>,A8 extends AggregateRoot<?>,A9 extends AggregateRoot<?>,A10 extends AggregateRoot<?>> MergeTupleWithRepositoryProvider<org.javatuples.Decade<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>> into(Class<A1> first,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A2> second,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A3> third,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A4> fourth,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A5> fifth,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A6> sixth,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A7> seventh,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A8> eighth,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A9> ninth,
                                                                                                                                                                                                                                                                                                                                                                                        Class<A10> tenth)

into

MergeTupleWithRepositoryProvider<org.javatuples.Tuple> into(List<Class<? extends AggregateRoot<?>>> aggregateRootClasses)

Merge the dto into a tuple of aggregate roots. This method is not recommended.

If you can, use the method matching the number of aggregate roots you have in the tuple. For instance use into(Class, Class) for a Pair<Customer, Order>. The result will be a more typed.

Parameters:

aggregateRootClasses - a list of aggregate root classes

Returns:

a tuple of aggregate roots

into

@Deprecated
void into(org.javatuples.Tuple aggregateRoots)

Deprecated.

Merge the dto into a tuple of aggregate roots. This method is not recommended.

If you can, use the method matching the number of aggregate roots you have in the tuple. For instance use into(org.seedstack.business.domain.AggregateRoot, org.seedstack.business.domain.AggregateRoot) for a Pair<Customer, Order> it will return a more typed result.

Parameters:

aggregateRoots - a list of aggregate root classes